@ind3x/cli-screens 1.0.0

package/dist/index.js

@@ -0,0 +1,2734 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// node:buffer
+var exports_buffer = {};
+__export(exports_buffer, {
+  transcode: () => transcode,
+  resolveObjectURL: () => resolveObjectURL,
+  kStringMaxLength: () => kStringMaxLength,
+  kMaxLength: () => kMaxLength,
+  isUtf8: () => isUtf8,
+  isAscii: () => isAscii,
+  default: () => buffer_default,
+  constants: () => constants,
+  btoa: () => btoa,
+  atob: () => atob,
+  INSPECT_MAX_BYTES: () => INSPECT_MAX_BYTES,
+  File: () => File,
+  Buffer: () => Buffer2,
+  Blob: () => Blob
+});
+function getLens(b64) {
+  var len2 = b64.length;
+  if (len2 % 4 > 0)
+    throw Error("Invalid string. Length must be a multiple of 4");
+  var validLen = b64.indexOf("=");
+  if (validLen === -1)
+    validLen = len2;
+  var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+  return [validLen, placeHoldersLen];
+}
+function _byteLength(validLen, placeHoldersLen) {
+  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function toByteArray(b64) {
+  var tmp, lens = getLens(b64), validLen = lens[0], placeHoldersLen = lens[1], arr = new Uint8Array(_byteLength(validLen, placeHoldersLen)), curByte = 0, len2 = placeHoldersLen > 0 ? validLen - 4 : validLen, i2;
+  for (i2 = 0;i2 < len2; i2 += 4)
+    tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)], arr[curByte++] = tmp >> 16 & 255, arr[curByte++] = tmp >> 8 & 255, arr[curByte++] = tmp & 255;
+  if (placeHoldersLen === 2)
+    tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4, arr[curByte++] = tmp & 255;
+  if (placeHoldersLen === 1)
+    tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2, arr[curByte++] = tmp >> 8 & 255, arr[curByte++] = tmp & 255;
+  return arr;
+}
+function tripletToBase64(num) {
+  return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+  var tmp, output = [];
+  for (var i2 = start;i2 < end; i2 += 3)
+    tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255), output.push(tripletToBase64(tmp));
+  return output.join("");
+}
+function fromByteArray(uint8) {
+  var tmp, len2 = uint8.length, extraBytes = len2 % 3, parts = [], maxChunkLength = 16383;
+  for (var i2 = 0, len22 = len2 - extraBytes;i2 < len22; i2 += maxChunkLength)
+    parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+  if (extraBytes === 1)
+    tmp = uint8[len2 - 1], parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+  else if (extraBytes === 2)
+    tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1], parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
+  return parts.join("");
+}
+function read(buffer, offset, isLE, mLen, nBytes) {
+  var e, m, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7, i2 = isLE ? nBytes - 1 : 0, d = isLE ? -1 : 1, s = buffer[offset + i2];
+  i2 += d, e = s & (1 << -nBits) - 1, s >>= -nBits, nBits += eLen;
+  for (;nBits > 0; e = e * 256 + buffer[offset + i2], i2 += d, nBits -= 8)
+    ;
+  m = e & (1 << -nBits) - 1, e >>= -nBits, nBits += mLen;
+  for (;nBits > 0; m = m * 256 + buffer[offset + i2], i2 += d, nBits -= 8)
+    ;
+  if (e === 0)
+    e = 1 - eBias;
+  else if (e === eMax)
+    return m ? NaN : (s ? -1 : 1) * (1 / 0);
+  else
+    m = m + Math.pow(2, mLen), e = e - eBias;
+  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+}
+function write(buffer, value, offset, isLE, mLen, nBytes) {
+  var e, m, c, eLen = nBytes * 8 - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, i2 = isLE ? 0 : nBytes - 1, d = isLE ? 1 : -1, s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+  if (value = Math.abs(value), isNaN(value) || value === 1 / 0)
+    m = isNaN(value) ? 1 : 0, e = eMax;
+  else {
+    if (e = Math.floor(Math.log(value) / Math.LN2), value * (c = Math.pow(2, -e)) < 1)
+      e--, c *= 2;
+    if (e + eBias >= 1)
+      value += rt / c;
+    else
+      value += rt * Math.pow(2, 1 - eBias);
+    if (value * c >= 2)
+      e++, c /= 2;
+    if (e + eBias >= eMax)
+      m = 0, e = eMax;
+    else if (e + eBias >= 1)
+      m = (value * c - 1) * Math.pow(2, mLen), e = e + eBias;
+    else
+      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen), e = 0;
+  }
+  for (;mLen >= 8; buffer[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8)
+    ;
+  e = e << mLen | m, eLen += mLen;
+  for (;eLen > 0; buffer[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8)
+    ;
+  buffer[offset + i2 - d] |= s * 128;
+}
+function createBuffer(length) {
+  if (length > kMaxLength)
+    throw RangeError('The value "' + length + '" is invalid for option "size"');
+  let buf = new Uint8Array(length);
+  return Object.setPrototypeOf(buf, Buffer2.prototype), buf;
+}
+function E(sym, getMessage, Base) {
+  return class extends Base {
+    constructor() {
+      super();
+      Object.defineProperty(this, "message", { value: getMessage.apply(this, arguments), writable: true, configurable: true }), this.name = `${this.name} [${sym}]`, this.stack, delete this.name;
+    }
+    get code() {
+      return sym;
+    }
+    set code(value) {
+      Object.defineProperty(this, "code", { configurable: true, enumerable: true, value, writable: true });
+    }
+    toString() {
+      return `${this.name} [${sym}]: ${this.message}`;
+    }
+  };
+}
+function Buffer2(arg, encodingOrOffset, length) {
+  if (typeof arg === "number") {
+    if (typeof encodingOrOffset === "string")
+      throw TypeError('The "string" argument must be of type string. Received type number');
+    return allocUnsafe(arg);
+  }
+  return from(arg, encodingOrOffset, length);
+}
+function from(value, encodingOrOffset, length) {
+  if (typeof value === "string")
+    return fromString(value, encodingOrOffset);
+  if (ArrayBuffer.isView(value))
+    return fromArrayView(value);
+  if (value == null)
+    throw TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+  if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer))
+    return fromArrayBuffer(value, encodingOrOffset, length);
+  if (typeof SharedArrayBuffer < "u" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer)))
+    return fromArrayBuffer(value, encodingOrOffset, length);
+  if (typeof value === "number")
+    throw TypeError('The "value" argument must not be of type number. Received type number');
+  let valueOf = value.valueOf && value.valueOf();
+  if (valueOf != null && valueOf !== value)
+    return Buffer2.from(valueOf, encodingOrOffset, length);
+  let b = fromObject(value);
+  if (b)
+    return b;
+  if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function")
+    return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+  throw TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+}
+function assertSize(size) {
+  if (typeof size !== "number")
+    throw TypeError('"size" argument must be of type number');
+  else if (size < 0)
+    throw RangeError('The value "' + size + '" is invalid for option "size"');
+}
+function alloc(size, fill, encoding) {
+  if (assertSize(size), size <= 0)
+    return createBuffer(size);
+  if (fill !== undefined)
+    return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+  return createBuffer(size);
+}
+function allocUnsafe(size) {
+  return assertSize(size), createBuffer(size < 0 ? 0 : checked(size) | 0);
+}
+function fromString(string, encoding) {
+  if (typeof encoding !== "string" || encoding === "")
+    encoding = "utf8";
+  if (!Buffer2.isEncoding(encoding))
+    throw TypeError("Unknown encoding: " + encoding);
+  let length = byteLength(string, encoding) | 0, buf = createBuffer(length), actual = buf.write(string, encoding);
+  if (actual !== length)
+    buf = buf.slice(0, actual);
+  return buf;
+}
+function fromArrayLike(array) {
+  let length = array.length < 0 ? 0 : checked(array.length) | 0, buf = createBuffer(length);
+  for (let i2 = 0;i2 < length; i2 += 1)
+    buf[i2] = array[i2] & 255;
+  return buf;
+}
+function fromArrayView(arrayView) {
+  if (isInstance(arrayView, Uint8Array)) {
+    let copy = new Uint8Array(arrayView);
+    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+  }
+  return fromArrayLike(arrayView);
+}
+function fromArrayBuffer(array, byteOffset, length) {
+  if (byteOffset < 0 || array.byteLength < byteOffset)
+    throw RangeError('"offset" is outside of buffer bounds');
+  if (array.byteLength < byteOffset + (length || 0))
+    throw RangeError('"length" is outside of buffer bounds');
+  let buf;
+  if (byteOffset === undefined && length === undefined)
+    buf = new Uint8Array(array);
+  else if (length === undefined)
+    buf = new Uint8Array(array, byteOffset);
+  else
+    buf = new Uint8Array(array, byteOffset, length);
+  return Object.setPrototypeOf(buf, Buffer2.prototype), buf;
+}
+function fromObject(obj) {
+  if (Buffer2.isBuffer(obj)) {
+    let len2 = checked(obj.length) | 0, buf = createBuffer(len2);
+    if (buf.length === 0)
+      return buf;
+    return obj.copy(buf, 0, 0, len2), buf;
+  }
+  if (obj.length !== undefined) {
+    if (typeof obj.length !== "number" || Number.isNaN(obj.length))
+      return createBuffer(0);
+    return fromArrayLike(obj);
+  }
+  if (obj.type === "Buffer" && Array.isArray(obj.data))
+    return fromArrayLike(obj.data);
+}
+function checked(length) {
+  if (length >= kMaxLength)
+    throw RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + kMaxLength.toString(16) + " bytes");
+  return length | 0;
+}
+function byteLength(string, encoding) {
+  if (Buffer2.isBuffer(string))
+    return string.length;
+  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer))
+    return string.byteLength;
+  if (typeof string !== "string")
+    throw TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
+  let len2 = string.length, mustMatch = arguments.length > 2 && arguments[2] === true;
+  if (!mustMatch && len2 === 0)
+    return 0;
+  let loweredCase = false;
+  for (;; )
+    switch (encoding) {
+      case "ascii":
+      case "latin1":
+      case "binary":
+        return len2;
+      case "utf8":
+      case "utf-8":
+        return utf8ToBytes(string).length;
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return len2 * 2;
+      case "hex":
+        return len2 >>> 1;
+      case "base64":
+        return base64ToBytes(string).length;
+      default:
+        if (loweredCase)
+          return mustMatch ? -1 : utf8ToBytes(string).length;
+        encoding = ("" + encoding).toLowerCase(), loweredCase = true;
+    }
+}
+function slowToString(encoding, start, end) {
+  let loweredCase = false;
+  if (start === undefined || start < 0)
+    start = 0;
+  if (start > this.length)
+    return "";
+  if (end === undefined || end > this.length)
+    end = this.length;
+  if (end <= 0)
+    return "";
+  if (end >>>= 0, start >>>= 0, end <= start)
+    return "";
+  if (!encoding)
+    encoding = "utf8";
+  while (true)
+    switch (encoding) {
+      case "hex":
+        return hexSlice(this, start, end);
+      case "utf8":
+      case "utf-8":
+        return utf8Slice(this, start, end);
+      case "ascii":
+        return asciiSlice(this, start, end);
+      case "latin1":
+      case "binary":
+        return latin1Slice(this, start, end);
+      case "base64":
+        return base64Slice(this, start, end);
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return utf16leSlice(this, start, end);
+      default:
+        if (loweredCase)
+          throw TypeError("Unknown encoding: " + encoding);
+        encoding = (encoding + "").toLowerCase(), loweredCase = true;
+    }
+}
+function swap(b, n, m) {
+  let i2 = b[n];
+  b[n] = b[m], b[m] = i2;
+}
+function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+  if (buffer.length === 0)
+    return -1;
+  if (typeof byteOffset === "string")
+    encoding = byteOffset, byteOffset = 0;
+  else if (byteOffset > 2147483647)
+    byteOffset = 2147483647;
+  else if (byteOffset < -2147483648)
+    byteOffset = -2147483648;
+  if (byteOffset = +byteOffset, Number.isNaN(byteOffset))
+    byteOffset = dir ? 0 : buffer.length - 1;
+  if (byteOffset < 0)
+    byteOffset = buffer.length + byteOffset;
+  if (byteOffset >= buffer.length)
+    if (dir)
+      return -1;
+    else
+      byteOffset = buffer.length - 1;
+  else if (byteOffset < 0)
+    if (dir)
+      byteOffset = 0;
+    else
+      return -1;
+  if (typeof val === "string")
+    val = Buffer2.from(val, encoding);
+  if (Buffer2.isBuffer(val)) {
+    if (val.length === 0)
+      return -1;
+    return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+  } else if (typeof val === "number") {
+    if (val = val & 255, typeof Uint8Array.prototype.indexOf === "function")
+      if (dir)
+        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+      else
+        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+  }
+  throw TypeError("val must be string, number or Buffer");
+}
+function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+  let indexSize = 1, arrLength = arr.length, valLength = val.length;
+  if (encoding !== undefined) {
+    if (encoding = String(encoding).toLowerCase(), encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+      if (arr.length < 2 || val.length < 2)
+        return -1;
+      indexSize = 2, arrLength /= 2, valLength /= 2, byteOffset /= 2;
+    }
+  }
+  function read2(buf, i3) {
+    if (indexSize === 1)
+      return buf[i3];
+    else
+      return buf.readUInt16BE(i3 * indexSize);
+  }
+  let i2;
+  if (dir) {
+    let foundIndex = -1;
+    for (i2 = byteOffset;i2 < arrLength; i2++)
+      if (read2(arr, i2) === read2(val, foundIndex === -1 ? 0 : i2 - foundIndex)) {
+        if (foundIndex === -1)
+          foundIndex = i2;
+        if (i2 - foundIndex + 1 === valLength)
+          return foundIndex * indexSize;
+      } else {
+        if (foundIndex !== -1)
+          i2 -= i2 - foundIndex;
+        foundIndex = -1;
+      }
+  } else {
+    if (byteOffset + valLength > arrLength)
+      byteOffset = arrLength - valLength;
+    for (i2 = byteOffset;i2 >= 0; i2--) {
+      let found = true;
+      for (let j = 0;j < valLength; j++)
+        if (read2(arr, i2 + j) !== read2(val, j)) {
+          found = false;
+          break;
+        }
+      if (found)
+        return i2;
+    }
+  }
+  return -1;
+}
+function hexWrite(buf, string, offset, length) {
+  offset = Number(offset) || 0;
+  let remaining = buf.length - offset;
+  if (!length)
+    length = remaining;
+  else if (length = Number(length), length > remaining)
+    length = remaining;
+  let strLen = string.length;
+  if (length > strLen / 2)
+    length = strLen / 2;
+  let i2;
+  for (i2 = 0;i2 < length; ++i2) {
+    let parsed = parseInt(string.substr(i2 * 2, 2), 16);
+    if (Number.isNaN(parsed))
+      return i2;
+    buf[offset + i2] = parsed;
+  }
+  return i2;
+}
+function utf8Write(buf, string, offset, length) {
+  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+}
+function asciiWrite(buf, string, offset, length) {
+  return blitBuffer(asciiToBytes(string), buf, offset, length);
+}
+function base64Write(buf, string, offset, length) {
+  return blitBuffer(base64ToBytes(string), buf, offset, length);
+}
+function ucs2Write(buf, string, offset, length) {
+  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+}
+function base64Slice(buf, start, end) {
+  if (start === 0 && end === buf.length)
+    return fromByteArray(buf);
+  else
+    return fromByteArray(buf.slice(start, end));
+}
+function utf8Slice(buf, start, end) {
+  end = Math.min(buf.length, end);
+  let res = [], i2 = start;
+  while (i2 < end) {
+    let firstByte = buf[i2], codePoint = null, bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+    if (i2 + bytesPerSequence <= end) {
+      let secondByte, thirdByte, fourthByte, tempCodePoint;
+      switch (bytesPerSequence) {
+        case 1:
+          if (firstByte < 128)
+            codePoint = firstByte;
+          break;
+        case 2:
+          if (secondByte = buf[i2 + 1], (secondByte & 192) === 128) {
+            if (tempCodePoint = (firstByte & 31) << 6 | secondByte & 63, tempCodePoint > 127)
+              codePoint = tempCodePoint;
+          }
+          break;
+        case 3:
+          if (secondByte = buf[i2 + 1], thirdByte = buf[i2 + 2], (secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+            if (tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63, tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343))
+              codePoint = tempCodePoint;
+          }
+          break;
+        case 4:
+          if (secondByte = buf[i2 + 1], thirdByte = buf[i2 + 2], fourthByte = buf[i2 + 3], (secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+            if (tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63, tempCodePoint > 65535 && tempCodePoint < 1114112)
+              codePoint = tempCodePoint;
+          }
+      }
+    }
+    if (codePoint === null)
+      codePoint = 65533, bytesPerSequence = 1;
+    else if (codePoint > 65535)
+      codePoint -= 65536, res.push(codePoint >>> 10 & 1023 | 55296), codePoint = 56320 | codePoint & 1023;
+    res.push(codePoint), i2 += bytesPerSequence;
+  }
+  return decodeCodePointsArray(res);
+}
+function decodeCodePointsArray(codePoints) {
+  let len2 = codePoints.length;
+  if (len2 <= MAX_ARGUMENTS_LENGTH)
+    return String.fromCharCode.apply(String, codePoints);
+  let res = "", i2 = 0;
+  while (i2 < len2)
+    res += String.fromCharCode.apply(String, codePoints.slice(i2, i2 += MAX_ARGUMENTS_LENGTH));
+  return res;
+}
+function asciiSlice(buf, start, end) {
+  let ret = "";
+  end = Math.min(buf.length, end);
+  for (let i2 = start;i2 < end; ++i2)
+    ret += String.fromCharCode(buf[i2] & 127);
+  return ret;
+}
+function latin1Slice(buf, start, end) {
+  let ret = "";
+  end = Math.min(buf.length, end);
+  for (let i2 = start;i2 < end; ++i2)
+    ret += String.fromCharCode(buf[i2]);
+  return ret;
+}
+function hexSlice(buf, start, end) {
+  let len2 = buf.length;
+  if (!start || start < 0)
+    start = 0;
+  if (!end || end < 0 || end > len2)
+    end = len2;
+  let out = "";
+  for (let i2 = start;i2 < end; ++i2)
+    out += hexSliceLookupTable[buf[i2]];
+  return out;
+}
+function utf16leSlice(buf, start, end) {
+  let bytes = buf.slice(start, end), res = "";
+  for (let i2 = 0;i2 < bytes.length - 1; i2 += 2)
+    res += String.fromCharCode(bytes[i2] + bytes[i2 + 1] * 256);
+  return res;
+}
+function checkOffset(offset, ext, length) {
+  if (offset % 1 !== 0 || offset < 0)
+    throw RangeError("offset is not uint");
+  if (offset + ext > length)
+    throw RangeError("Trying to access beyond buffer length");
+}
+function checkInt(buf, value, offset, ext, max, min) {
+  if (!Buffer2.isBuffer(buf))
+    throw TypeError('"buffer" argument must be a Buffer instance');
+  if (value > max || value < min)
+    throw RangeError('"value" argument is out of bounds');
+  if (offset + ext > buf.length)
+    throw RangeError("Index out of range");
+}
+function wrtBigUInt64LE(buf, value, offset, min, max) {
+  checkIntBI(value, min, max, buf, offset, 7);
+  let lo = Number(value & BigInt(4294967295));
+  buf[offset++] = lo, lo = lo >> 8, buf[offset++] = lo, lo = lo >> 8, buf[offset++] = lo, lo = lo >> 8, buf[offset++] = lo;
+  let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+  return buf[offset++] = hi, hi = hi >> 8, buf[offset++] = hi, hi = hi >> 8, buf[offset++] = hi, hi = hi >> 8, buf[offset++] = hi, offset;
+}
+function wrtBigUInt64BE(buf, value, offset, min, max) {
+  checkIntBI(value, min, max, buf, offset, 7);
+  let lo = Number(value & BigInt(4294967295));
+  buf[offset + 7] = lo, lo = lo >> 8, buf[offset + 6] = lo, lo = lo >> 8, buf[offset + 5] = lo, lo = lo >> 8, buf[offset + 4] = lo;
+  let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+  return buf[offset + 3] = hi, hi = hi >> 8, buf[offset + 2] = hi, hi = hi >> 8, buf[offset + 1] = hi, hi = hi >> 8, buf[offset] = hi, offset + 8;
+}
+function checkIEEE754(buf, value, offset, ext, max, min) {
+  if (offset + ext > buf.length)
+    throw RangeError("Index out of range");
+  if (offset < 0)
+    throw RangeError("Index out of range");
+}
+function writeFloat(buf, value, offset, littleEndian, noAssert) {
+  if (value = +value, offset = offset >>> 0, !noAssert)
+    checkIEEE754(buf, value, offset, 4, 340282346638528860000000000000000000000, -340282346638528860000000000000000000000);
+  return write(buf, value, offset, littleEndian, 23, 4), offset + 4;
+}
+function writeDouble(buf, value, offset, littleEndian, noAssert) {
+  if (value = +value, offset = offset >>> 0, !noAssert)
+    checkIEEE754(buf, value, offset, 8, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000);
+  return write(buf, value, offset, littleEndian, 52, 8), offset + 8;
+}
+function addNumericalSeparator(val) {
+  let res = "", i2 = val.length, start = val[0] === "-" ? 1 : 0;
+  for (;i2 >= start + 4; i2 -= 3)
+    res = `_${val.slice(i2 - 3, i2)}${res}`;
+  return `${val.slice(0, i2)}${res}`;
+}
+function checkBounds(buf, offset, byteLength2) {
+  if (validateNumber(offset, "offset"), buf[offset] === undefined || buf[offset + byteLength2] === undefined)
+    boundsError(offset, buf.length - (byteLength2 + 1));
+}
+function checkIntBI(value, min, max, buf, offset, byteLength2) {
+  if (value > max || value < min) {
+    let n = typeof min === "bigint" ? "n" : "", range;
+    if (byteLength2 > 3)
+      if (min === 0 || min === BigInt(0))
+        range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
+      else
+        range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
+    else
+      range = `>= ${min}${n} and <= ${max}${n}`;
+    throw new ERR_OUT_OF_RANGE("value", range, value);
+  }
+  checkBounds(buf, offset, byteLength2);
+}
+function validateNumber(value, name) {
+  if (typeof value !== "number")
+    throw new ERR_INVALID_ARG_TYPE(name, "number", value);
+}
+function boundsError(value, length, type) {
+  if (Math.floor(value) !== value)
+    throw validateNumber(value, type), new ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
+  if (length < 0)
+    throw new ERR_BUFFER_OUT_OF_BOUNDS;
+  throw new ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
+}
+function base64clean(str) {
+  if (str = str.split("=")[0], str = str.trim().replace(INVALID_BASE64_RE, ""), str.length < 2)
+    return "";
+  while (str.length % 4 !== 0)
+    str = str + "=";
+  return str;
+}
+function utf8ToBytes(string, units) {
+  units = units || 1 / 0;
+  let codePoint, length = string.length, leadSurrogate = null, bytes = [];
+  for (let i2 = 0;i2 < length; ++i2) {
+    if (codePoint = string.charCodeAt(i2), codePoint > 55295 && codePoint < 57344) {
+      if (!leadSurrogate) {
+        if (codePoint > 56319) {
+          if ((units -= 3) > -1)
+            bytes.push(239, 191, 189);
+          continue;
+        } else if (i2 + 1 === length) {
+          if ((units -= 3) > -1)
+            bytes.push(239, 191, 189);
+          continue;
+        }
+        leadSurrogate = codePoint;
+        continue;
+      }
+      if (codePoint < 56320) {
+        if ((units -= 3) > -1)
+          bytes.push(239, 191, 189);
+        leadSurrogate = codePoint;
+        continue;
+      }
+      codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+    } else if (leadSurrogate) {
+      if ((units -= 3) > -1)
+        bytes.push(239, 191, 189);
+    }
+    if (leadSurrogate = null, codePoint < 128) {
+      if ((units -= 1) < 0)
+        break;
+      bytes.push(codePoint);
+    } else if (codePoint < 2048) {
+      if ((units -= 2) < 0)
+        break;
+      bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
+    } else if (codePoint < 65536) {
+      if ((units -= 3) < 0)
+        break;
+      bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+    } else if (codePoint < 1114112) {
+      if ((units -= 4) < 0)
+        break;
+      bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+    } else
+      throw Error("Invalid code point");
+  }
+  return bytes;
+}
+function asciiToBytes(str) {
+  let byteArray = [];
+  for (let i2 = 0;i2 < str.length; ++i2)
+    byteArray.push(str.charCodeAt(i2) & 255);
+  return byteArray;
+}
+function utf16leToBytes(str, units) {
+  let c, hi, lo, byteArray = [];
+  for (let i2 = 0;i2 < str.length; ++i2) {
+    if ((units -= 2) < 0)
+      break;
+    c = str.charCodeAt(i2), hi = c >> 8, lo = c % 256, byteArray.push(lo), byteArray.push(hi);
+  }
+  return byteArray;
+}
+function base64ToBytes(str) {
+  return toByteArray(base64clean(str));
+}
+function blitBuffer(src, dst, offset, length) {
+  let i2;
+  for (i2 = 0;i2 < length; ++i2) {
+    if (i2 + offset >= dst.length || i2 >= src.length)
+      break;
+    dst[i2 + offset] = src[i2];
+  }
+  return i2;
+}
+function isInstance(obj, type) {
+  return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+}
+function defineBigIntMethod(fn) {
+  return typeof BigInt > "u" ? BufferBigIntNotDefined : fn;
+}
+function BufferBigIntNotDefined() {
+  throw Error("BigInt not supported");
+}
+function notimpl(name) {
+  return () => {
+    throw Error(name + " is not implemented for node:buffer browser polyfill");
+  };
+}
+var lookup, revLookup, code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", i, len, customInspectSymbol, INSPECT_MAX_BYTES = 50, kMaxLength = 2147483647, kStringMaxLength = 536870888, btoa, atob, File, Blob, constants, ERR_BUFFER_OUT_OF_BOUNDS, ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE, MAX_ARGUMENTS_LENGTH = 4096, INVALID_BASE64_RE, hexSliceLookupTable, resolveObjectURL, isUtf8, isAscii = (str) => {
+  for (let char of str)
+    if (char.charCodeAt(0) > 127)
+      return false;
+  return true;
+}, transcode, buffer_default;
+var init_buffer = __esm(() => {
+  lookup = [];
+  revLookup = [];
+  for (i = 0, len = code.length;i < len; ++i)
+    lookup[i] = code[i], revLookup[code.charCodeAt(i)] = i;
+  revLookup[45] = 62;
+  revLookup[95] = 63;
+  customInspectSymbol = typeof Symbol === "function" && typeof Symbol.for === "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
+  btoa = globalThis.btoa;
+  atob = globalThis.atob;
+  File = globalThis.File;
+  Blob = globalThis.Blob;
+  constants = { MAX_LENGTH: kMaxLength, MAX_STRING_LENGTH: kStringMaxLength };
+  ERR_BUFFER_OUT_OF_BOUNDS = E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
+    if (name)
+      return `${name} is outside of buffer bounds`;
+    return "Attempt to access memory outside buffer bounds";
+  }, RangeError);
+  ERR_INVALID_ARG_TYPE = E("ERR_INVALID_ARG_TYPE", function(name, actual) {
+    return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
+  }, TypeError);
+  ERR_OUT_OF_RANGE = E("ERR_OUT_OF_RANGE", function(str, range, input) {
+    let msg = `The value of "${str}" is out of range.`, received = input;
+    if (Number.isInteger(input) && Math.abs(input) > 4294967296)
+      received = addNumericalSeparator(String(input));
+    else if (typeof input === "bigint") {
+      if (received = String(input), input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32)))
+        received = addNumericalSeparator(received);
+      received += "n";
+    }
+    return msg += ` It must be ${range}. Received ${received}`, msg;
+  }, RangeError);
+  Object.defineProperty(Buffer2.prototype, "parent", { enumerable: true, get: function() {
+    if (!Buffer2.isBuffer(this))
+      return;
+    return this.buffer;
+  } });
+  Object.defineProperty(Buffer2.prototype, "offset", { enumerable: true, get: function() {
+    if (!Buffer2.isBuffer(this))
+      return;
+    return this.byteOffset;
+  } });
+  Buffer2.poolSize = 8192;
+  Buffer2.from = function(value, encodingOrOffset, length) {
+    return from(value, encodingOrOffset, length);
+  };
+  Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
+  Object.setPrototypeOf(Buffer2, Uint8Array);
+  Buffer2.alloc = function(size, fill, encoding) {
+    return alloc(size, fill, encoding);
+  };
+  Buffer2.allocUnsafe = function(size) {
+    return allocUnsafe(size);
+  };
+  Buffer2.allocUnsafeSlow = function(size) {
+    return allocUnsafe(size);
+  };
+  Buffer2.isBuffer = function(b) {
+    return b != null && b._isBuffer === true && b !== Buffer2.prototype;
+  };
+  Buffer2.compare = function(a, b) {
+    if (isInstance(a, Uint8Array))
+      a = Buffer2.from(a, a.offset, a.byteLength);
+    if (isInstance(b, Uint8Array))
+      b = Buffer2.from(b, b.offset, b.byteLength);
+    if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b))
+      throw TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+    if (a === b)
+      return 0;
+    let x = a.length, y = b.length;
+    for (let i2 = 0, len2 = Math.min(x, y);i2 < len2; ++i2)
+      if (a[i2] !== b[i2]) {
+        x = a[i2], y = b[i2];
+        break;
+      }
+    if (x < y)
+      return -1;
+    if (y < x)
+      return 1;
+    return 0;
+  };
+  Buffer2.isEncoding = function(encoding) {
+    switch (String(encoding).toLowerCase()) {
+      case "hex":
+      case "utf8":
+      case "utf-8":
+      case "ascii":
+      case "latin1":
+      case "binary":
+      case "base64":
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return true;
+      default:
+        return false;
+    }
+  };
+  Buffer2.concat = function(list, length) {
+    if (!Array.isArray(list))
+      throw TypeError('"list" argument must be an Array of Buffers');
+    if (list.length === 0)
+      return Buffer2.alloc(0);
+    let i2;
+    if (length === undefined) {
+      length = 0;
+      for (i2 = 0;i2 < list.length; ++i2)
+        length += list[i2].length;
+    }
+    let buffer = Buffer2.allocUnsafe(length), pos = 0;
+    for (i2 = 0;i2 < list.length; ++i2) {
+      let buf = list[i2];
+      if (isInstance(buf, Uint8Array))
+        if (pos + buf.length > buffer.length) {
+          if (!Buffer2.isBuffer(buf))
+            buf = Buffer2.from(buf);
+          buf.copy(buffer, pos);
+        } else
+          Uint8Array.prototype.set.call(buffer, buf, pos);
+      else if (!Buffer2.isBuffer(buf))
+        throw TypeError('"list" argument must be an Array of Buffers');
+      else
+        buf.copy(buffer, pos);
+      pos += buf.length;
+    }
+    return buffer;
+  };
+  Buffer2.byteLength = byteLength;
+  Buffer2.prototype._isBuffer = true;
+  Buffer2.prototype.swap16 = function() {
+    let len2 = this.length;
+    if (len2 % 2 !== 0)
+      throw RangeError("Buffer size must be a multiple of 16-bits");
+    for (let i2 = 0;i2 < len2; i2 += 2)
+      swap(this, i2, i2 + 1);
+    return this;
+  };
+  Buffer2.prototype.swap32 = function() {
+    let len2 = this.length;
+    if (len2 % 4 !== 0)
+      throw RangeError("Buffer size must be a multiple of 32-bits");
+    for (let i2 = 0;i2 < len2; i2 += 4)
+      swap(this, i2, i2 + 3), swap(this, i2 + 1, i2 + 2);
+    return this;
+  };
+  Buffer2.prototype.swap64 = function() {
+    let len2 = this.length;
+    if (len2 % 8 !== 0)
+      throw RangeError("Buffer size must be a multiple of 64-bits");
+    for (let i2 = 0;i2 < len2; i2 += 8)
+      swap(this, i2, i2 + 7), swap(this, i2 + 1, i2 + 6), swap(this, i2 + 2, i2 + 5), swap(this, i2 + 3, i2 + 4);
+    return this;
+  };
+  Buffer2.prototype.toString = function() {
+    let length = this.length;
+    if (length === 0)
+      return "";
+    if (arguments.length === 0)
+      return utf8Slice(this, 0, length);
+    return slowToString.apply(this, arguments);
+  };
+  Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
+  Buffer2.prototype.equals = function(b) {
+    if (!Buffer2.isBuffer(b))
+      throw TypeError("Argument must be a Buffer");
+    if (this === b)
+      return true;
+    return Buffer2.compare(this, b) === 0;
+  };
+  Buffer2.prototype.inspect = function() {
+    let str = "", max = INSPECT_MAX_BYTES;
+    if (str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(), this.length > max)
+      str += " ... ";
+    return "<Buffer " + str + ">";
+  };
+  if (customInspectSymbol)
+    Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
+  Buffer2.prototype.compare = function(target, start, end, thisStart, thisEnd) {
+    if (isInstance(target, Uint8Array))
+      target = Buffer2.from(target, target.offset, target.byteLength);
+    if (!Buffer2.isBuffer(target))
+      throw TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
+    if (start === undefined)
+      start = 0;
+    if (end === undefined)
+      end = target ? target.length : 0;
+    if (thisStart === undefined)
+      thisStart = 0;
+    if (thisEnd === undefined)
+      thisEnd = this.length;
+    if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length)
+      throw RangeError("out of range index");
+    if (thisStart >= thisEnd && start >= end)
+      return 0;
+    if (thisStart >= thisEnd)
+      return -1;
+    if (start >= end)
+      return 1;
+    if (start >>>= 0, end >>>= 0, thisStart >>>= 0, thisEnd >>>= 0, this === target)
+      return 0;
+    let x = thisEnd - thisStart, y = end - start, len2 = Math.min(x, y), thisCopy = this.slice(thisStart, thisEnd), targetCopy = target.slice(start, end);
+    for (let i2 = 0;i2 < len2; ++i2)
+      if (thisCopy[i2] !== targetCopy[i2]) {
+        x = thisCopy[i2], y = targetCopy[i2];
+        break;
+      }
+    if (x < y)
+      return -1;
+    if (y < x)
+      return 1;
+    return 0;
+  };
+  Buffer2.prototype.includes = function(val, byteOffset, encoding) {
+    return this.indexOf(val, byteOffset, encoding) !== -1;
+  };
+  Buffer2.prototype.indexOf = function(val, byteOffset, encoding) {
+    return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+  };
+  Buffer2.prototype.lastIndexOf = function(val, byteOffset, encoding) {
+    return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+  };
+  Buffer2.prototype.write = function(string, offset, length, encoding) {
+    if (offset === undefined)
+      encoding = "utf8", length = this.length, offset = 0;
+    else if (length === undefined && typeof offset === "string")
+      encoding = offset, length = this.length, offset = 0;
+    else if (isFinite(offset))
+      if (offset = offset >>> 0, isFinite(length)) {
+        if (length = length >>> 0, encoding === undefined)
+          encoding = "utf8";
+      } else
+        encoding = length, length = undefined;
+    else
+      throw Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+    let remaining = this.length - offset;
+    if (length === undefined || length > remaining)
+      length = remaining;
+    if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length)
+      throw RangeError("Attempt to write outside buffer bounds");
+    if (!encoding)
+      encoding = "utf8";
+    let loweredCase = false;
+    for (;; )
+      switch (encoding) {
+        case "hex":
+          return hexWrite(this, string, offset, length);
+        case "utf8":
+        case "utf-8":
+          return utf8Write(this, string, offset, length);
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return asciiWrite(this, string, offset, length);
+        case "base64":
+          return base64Write(this, string, offset, length);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return ucs2Write(this, string, offset, length);
+        default:
+          if (loweredCase)
+            throw TypeError("Unknown encoding: " + encoding);
+          encoding = ("" + encoding).toLowerCase(), loweredCase = true;
+      }
+  };
+  Buffer2.prototype.toJSON = function() {
+    return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
+  };
+  Buffer2.prototype.slice = function(start, end) {
+    let len2 = this.length;
+    if (start = ~~start, end = end === undefined ? len2 : ~~end, start < 0) {
+      if (start += len2, start < 0)
+        start = 0;
+    } else if (start > len2)
+      start = len2;
+    if (end < 0) {
+      if (end += len2, end < 0)
+        end = 0;
+    } else if (end > len2)
+      end = len2;
+    if (end < start)
+      end = start;
+    let newBuf = this.subarray(start, end);
+    return Object.setPrototypeOf(newBuf, Buffer2.prototype), newBuf;
+  };
+  Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function(offset, byteLength2, noAssert) {
+    if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
+      checkOffset(offset, byteLength2, this.length);
+    let val = this[offset], mul = 1, i2 = 0;
+    while (++i2 < byteLength2 && (mul *= 256))
+      val += this[offset + i2] * mul;
+    return val;
+  };
+  Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function(offset, byteLength2, noAssert) {
+    if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
+      checkOffset(offset, byteLength2, this.length);
+    let val = this[offset + --byteLength2], mul = 1;
+    while (byteLength2 > 0 && (mul *= 256))
+      val += this[offset + --byteLength2] * mul;
+    return val;
+  };
+  Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 1, this.length);
+    return this[offset];
+  };
+  Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 2, this.length);
+    return this[offset] | this[offset + 1] << 8;
+  };
+  Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 2, this.length);
+    return this[offset] << 8 | this[offset + 1];
+  };
+  Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 4, this.length);
+    return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+  };
+  Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 4, this.length);
+    return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+  };
+  Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function(offset) {
+    offset = offset >>> 0, validateNumber(offset, "offset");
+    let first = this[offset], last = this[offset + 7];
+    if (first === undefined || last === undefined)
+      boundsError(offset, this.length - 8);
+    let lo = first + this[++offset] * 256 + this[++offset] * 65536 + this[++offset] * 16777216, hi = this[++offset] + this[++offset] * 256 + this[++offset] * 65536 + last * 16777216;
+    return BigInt(lo) + (BigInt(hi) << BigInt(32));
+  });
+  Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function(offset) {
+    offset = offset >>> 0, validateNumber(offset, "offset");
+    let first = this[offset], last = this[offset + 7];
+    if (first === undefined || last === undefined)
+      boundsError(offset, this.length - 8);
+    let hi = first * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + this[++offset], lo = this[++offset] * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + last;
+    return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+  });
+  Buffer2.prototype.readIntLE = function(offset, byteLength2, noAssert) {
+    if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
+      checkOffset(offset, byteLength2, this.length);
+    let val = this[offset], mul = 1, i2 = 0;
+    while (++i2 < byteLength2 && (mul *= 256))
+      val += this[offset + i2] * mul;
+    if (mul *= 128, val >= mul)
+      val -= Math.pow(2, 8 * byteLength2);
+    return val;
+  };
+  Buffer2.prototype.readIntBE = function(offset, byteLength2, noAssert) {
+    if (offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert)
+      checkOffset(offset, byteLength2, this.length);
+    let i2 = byteLength2, mul = 1, val = this[offset + --i2];
+    while (i2 > 0 && (mul *= 256))
+      val += this[offset + --i2] * mul;
+    if (mul *= 128, val >= mul)
+      val -= Math.pow(2, 8 * byteLength2);
+    return val;
+  };
+  Buffer2.prototype.readInt8 = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 1, this.length);
+    if (!(this[offset] & 128))
+      return this[offset];
+    return (255 - this[offset] + 1) * -1;
+  };
+  Buffer2.prototype.readInt16LE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 2, this.length);
+    let val = this[offset] | this[offset + 1] << 8;
+    return val & 32768 ? val | 4294901760 : val;
+  };
+  Buffer2.prototype.readInt16BE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 2, this.length);
+    let val = this[offset + 1] | this[offset] << 8;
+    return val & 32768 ? val | 4294901760 : val;
+  };
+  Buffer2.prototype.readInt32LE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 4, this.length);
+    return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+  };
+  Buffer2.prototype.readInt32BE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 4, this.length);
+    return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+  };
+  Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function(offset) {
+    offset = offset >>> 0, validateNumber(offset, "offset");
+    let first = this[offset], last = this[offset + 7];
+    if (first === undefined || last === undefined)
+      boundsError(offset, this.length - 8);
+    let val = this[offset + 4] + this[offset + 5] * 256 + this[offset + 6] * 65536 + (last << 24);
+    return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 256 + this[++offset] * 65536 + this[++offset] * 16777216);
+  });
+  Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function(offset) {
+    offset = offset >>> 0, validateNumber(offset, "offset");
+    let first = this[offset], last = this[offset + 7];
+    if (first === undefined || last === undefined)
+      boundsError(offset, this.length - 8);
+    let val = (first << 24) + this[++offset] * 65536 + this[++offset] * 256 + this[++offset];
+    return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 16777216 + this[++offset] * 65536 + this[++offset] * 256 + last);
+  });
+  Buffer2.prototype.readFloatLE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 4, this.length);
+    return read(this, offset, true, 23, 4);
+  };
+  Buffer2.prototype.readFloatBE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 4, this.length);
+    return read(this, offset, false, 23, 4);
+  };
+  Buffer2.prototype.readDoubleLE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 8, this.length);
+    return read(this, offset, true, 52, 8);
+  };
+  Buffer2.prototype.readDoubleBE = function(offset, noAssert) {
+    if (offset = offset >>> 0, !noAssert)
+      checkOffset(offset, 8, this.length);
+    return read(this, offset, false, 52, 8);
+  };
+  Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function(value, offset, byteLength2, noAssert) {
+    if (value = +value, offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert) {
+      let maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+      checkInt(this, value, offset, byteLength2, maxBytes, 0);
+    }
+    let mul = 1, i2 = 0;
+    this[offset] = value & 255;
+    while (++i2 < byteLength2 && (mul *= 256))
+      this[offset + i2] = value / mul & 255;
+    return offset + byteLength2;
+  };
+  Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function(value, offset, byteLength2, noAssert) {
+    if (value = +value, offset = offset >>> 0, byteLength2 = byteLength2 >>> 0, !noAssert) {
+      let maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+      checkInt(this, value, offset, byteLength2, maxBytes, 0);
+    }
+    let i2 = byteLength2 - 1, mul = 1;
+    this[offset + i2] = value & 255;
+    while (--i2 >= 0 && (mul *= 256))
+      this[offset + i2] = value / mul & 255;
+    return offset + byteLength2;
+  };
+  Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function(value, offset, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert)
+      checkInt(this, value, offset, 1, 255, 0);
+    return this[offset] = value & 255, offset + 1;
+  };
+  Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function(value, offset, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert)
+      checkInt(this, value, offset, 2, 65535, 0);
+    return this[offset] = value & 255, this[offset + 1] = value >>> 8, offset + 2;
+  };
+  Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function(value, offset, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert)
+      checkInt(this, value, offset, 2, 65535, 0);
+    return this[offset] = value >>> 8, this[offset + 1] = value & 255, offset + 2;
+  };
+  Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function(value, offset, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert)
+      checkInt(this, value, offset, 4, 4294967295, 0);
+    return this[offset + 3] = value >>> 24, this[offset + 2] = value >>> 16, this[offset + 1] = value >>> 8, this[offset] = value & 255, offset + 4;
+  };
+  Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function(value, offset, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert)
+      checkInt(this, value, offset, 4, 4294967295, 0);
+    return this[offset] = value >>> 24, this[offset + 1] = value >>> 16, this[offset + 2] = value >>> 8, this[offset + 3] = value & 255, offset + 4;
+  };
+  Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function(value, offset = 0) {
+    return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+  });
+  Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function(value, offset = 0) {
+    return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+  });
+  Buffer2.prototype.writeIntLE = function(value, offset, byteLength2, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert) {
+      let limit = Math.pow(2, 8 * byteLength2 - 1);
+      checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+    }
+    let i2 = 0, mul = 1, sub = 0;
+    this[offset] = value & 255;
+    while (++i2 < byteLength2 && (mul *= 256)) {
+      if (value < 0 && sub === 0 && this[offset + i2 - 1] !== 0)
+        sub = 1;
+      this[offset + i2] = (value / mul >> 0) - sub & 255;
+    }
+    return offset + byteLength2;
+  };
+  Buffer2.prototype.writeIntBE = function(value, offset, byteLength2, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert) {
+      let limit = Math.pow(2, 8 * byteLength2 - 1);
+      checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+    }
+    let i2 = byteLength2 - 1, mul = 1, sub = 0;
+    this[offset + i2] = value & 255;
+    while (--i2 >= 0 && (mul *= 256)) {
+      if (value < 0 && sub === 0 && this[offset + i2 + 1] !== 0)
+        sub = 1;
+      this[offset + i2] = (value / mul >> 0) - sub & 255;
+    }
+    return offset + byteLength2;
+  };
+  Buffer2.prototype.writeInt8 = function(value, offset, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert)
+      checkInt(this, value, offset, 1, 127, -128);
+    if (value < 0)
+      value = 255 + value + 1;
+    return this[offset] = value & 255, offset + 1;
+  };
+  Buffer2.prototype.writeInt16LE = function(value, offset, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert)
+      checkInt(this, value, offset, 2, 32767, -32768);
+    return this[offset] = value & 255, this[offset + 1] = value >>> 8, offset + 2;
+  };
+  Buffer2.prototype.writeInt16BE = function(value, offset, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert)
+      checkInt(this, value, offset, 2, 32767, -32768);
+    return this[offset] = value >>> 8, this[offset + 1] = value & 255, offset + 2;
+  };
+  Buffer2.prototype.writeInt32LE = function(value, offset, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert)
+      checkInt(this, value, offset, 4, 2147483647, -2147483648);
+    return this[offset] = value & 255, this[offset + 1] = value >>> 8, this[offset + 2] = value >>> 16, this[offset + 3] = value >>> 24, offset + 4;
+  };
+  Buffer2.prototype.writeInt32BE = function(value, offset, noAssert) {
+    if (value = +value, offset = offset >>> 0, !noAssert)
+      checkInt(this, value, offset, 4, 2147483647, -2147483648);
+    if (value < 0)
+      value = 4294967295 + value + 1;
+    return this[offset] = value >>> 24, this[offset + 1] = value >>> 16, this[offset + 2] = value >>> 8, this[offset + 3] = value & 255, offset + 4;
+  };
+  Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function(value, offset = 0) {
+    return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  });
+  Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function(value, offset = 0) {
+    return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  });
+  Buffer2.prototype.writeFloatLE = function(value, offset, noAssert) {
+    return writeFloat(this, value, offset, true, noAssert);
+  };
+  Buffer2.prototype.writeFloatBE = function(value, offset, noAssert) {
+    return writeFloat(this, value, offset, false, noAssert);
+  };
+  Buffer2.prototype.writeDoubleLE = function(value, offset, noAssert) {
+    return writeDouble(this, value, offset, true, noAssert);
+  };
+  Buffer2.prototype.writeDoubleBE = function(value, offset, noAssert) {
+    return writeDouble(this, value, offset, false, noAssert);
+  };
+  Buffer2.prototype.copy = function(target, targetStart, start, end) {
+    if (!Buffer2.isBuffer(target))
+      throw TypeError("argument should be a Buffer");
+    if (!start)
+      start = 0;
+    if (!end && end !== 0)
+      end = this.length;
+    if (targetStart >= target.length)
+      targetStart = target.length;
+    if (!targetStart)
+      targetStart = 0;
+    if (end > 0 && end < start)
+      end = start;
+    if (end === start)
+      return 0;
+    if (target.length === 0 || this.length === 0)
+      return 0;
+    if (targetStart < 0)
+      throw RangeError("targetStart out of bounds");
+    if (start < 0 || start >= this.length)
+      throw RangeError("Index out of range");
+    if (end < 0)
+      throw RangeError("sourceEnd out of bounds");
+    if (end > this.length)
+      end = this.length;
+    if (target.length - targetStart < end - start)
+      end = target.length - targetStart + start;
+    let len2 = end - start;
+    if (this === target && typeof Uint8Array.prototype.copyWithin === "function")
+      this.copyWithin(targetStart, start, end);
+    else
+      Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
+    return len2;
+  };
+  Buffer2.prototype.fill = function(val, start, end, encoding) {
+    if (typeof val === "string") {
+      if (typeof start === "string")
+        encoding = start, start = 0, end = this.length;
+      else if (typeof end === "string")
+        encoding = end, end = this.length;
+      if (encoding !== undefined && typeof encoding !== "string")
+        throw TypeError("encoding must be a string");
+      if (typeof encoding === "string" && !Buffer2.isEncoding(encoding))
+        throw TypeError("Unknown encoding: " + encoding);
+      if (val.length === 1) {
+        let code2 = val.charCodeAt(0);
+        if (encoding === "utf8" && code2 < 128 || encoding === "latin1")
+          val = code2;
+      }
+    } else if (typeof val === "number")
+      val = val & 255;
+    else if (typeof val === "boolean")
+      val = Number(val);
+    if (start < 0 || this.length < start || this.length < end)
+      throw RangeError("Out of range index");
+    if (end <= start)
+      return this;
+    if (start = start >>> 0, end = end === undefined ? this.length : end >>> 0, !val)
+      val = 0;
+    let i2;
+    if (typeof val === "number")
+      for (i2 = start;i2 < end; ++i2)
+        this[i2] = val;
+    else {
+      let bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding), len2 = bytes.length;
+      if (len2 === 0)
+        throw TypeError('The value "' + val + '" is invalid for argument "value"');
+      for (i2 = 0;i2 < end - start; ++i2)
+        this[i2 + start] = bytes[i2 % len2];
+    }
+    return this;
+  };
+  INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+  hexSliceLookupTable = function() {
+    let table = Array(256);
+    for (let i2 = 0;i2 < 16; ++i2) {
+      let i16 = i2 * 16;
+      for (let j = 0;j < 16; ++j)
+        table[i16 + j] = "0123456789abcdef"[i2] + "0123456789abcdef"[j];
+    }
+    return table;
+  }();
+  resolveObjectURL = notimpl("resolveObjectURL");
+  isUtf8 = notimpl("isUtf8");
+  transcode = notimpl("transcode");
+  buffer_default = Buffer2;
+});
+
+// src/type/text.ts
+var colors = {
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  brightBlack: "\x1B[90m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  brightWhite: "\x1B[97m",
+  accent: "\x1B[34m",
+  muted: "\x1B[2m",
+  default: "\x1B[0m"
+};
+var AnsiCode = {
+  reset: "\x1B[0m",
+  clear: "\x1B[H\x1B[2J",
+  hideCursor: "\x1B[?25l",
+  showCursor: "\x1B[?25h"
+};
+
+// src/renderer/text-layout.ts
+var ansiPattern = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+function characterWidth(character) {
+  const code = character.codePointAt(0) ?? 0;
+  if (code === 0 || code < 32 || code >= 127 && code < 160 || /\p{Mark}/u.test(character) || code === 8205 || code >= 65024 && code <= 65039) {
+    return 0;
+  }
+  return isWide(code) ? 2 : 1;
+}
+function textWidth(value) {
+  return Array.from(value.replace(ansiPattern, "")).reduce((width, character) => width + characterWidth(character), 0);
+}
+function truncate(value, width) {
+  if (width <= 0) {
+    return "";
+  }
+  let output = "";
+  let currentWidth = 0;
+  let offset = 0;
+  while (offset < value.length) {
+    const ansi = value.slice(offset).match(/^\x1b\[[0-?]*[ -/]*[@-~]/)?.[0];
+    if (ansi) {
+      output += ansi;
+      offset += ansi.length;
+      continue;
+    }
+    const character = Array.from(value.slice(offset))[0] ?? "";
+    const nextWidth = characterWidth(character);
+    if (currentWidth + nextWidth > width) {
+      break;
+    }
+    output += character;
+    currentWidth += nextWidth;
+    offset += character.length;
+  }
+  return output;
+}
+function wrap(value, width) {
+  if (width <= 0) {
+    return [""];
+  }
+  if (textWidth(value) <= width) {
+    return [value];
+  }
+  const lines = [];
+  let remaining = value;
+  while (remaining.length > 0) {
+    const line = truncate(remaining, width);
+    if (!line) {
+      break;
+    }
+    lines.push(line);
+    remaining = remaining.slice(line.length);
+  }
+  return lines.length > 0 ? lines : [""];
+}
+function isWide(code) {
+  return code >= 4352 && (code <= 4447 || code === 9001 || code === 9002 || code >= 11904 && code <= 42191 && code !== 12351 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65040 && code <= 65049 || code >= 65072 && code <= 65135 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 127744 && code <= 129791 || code >= 131072 && code <= 262141);
+}
+
+// src/renderer/ui.ts
+class Ui {
+  width;
+  height;
+  lines = [];
+  constructor(width, height = 24) {
+    this.width = width;
+    this.height = height;
+  }
+  style(value, { tone = "default" } = {}) {
+    return `${colors[tone]}${value}${AnsiCode.reset}`;
+  }
+  text(value, { tone = "default" } = {}) {
+    const sourceLines = value.split(`
+`);
+    for (const sourceLine of sourceLines) {
+      for (const line of wrap(sourceLine, this.width)) {
+        this.lines.push(`${colors[tone]}${line}${AnsiCode.reset}`);
+      }
+    }
+  }
+  blank() {
+    this.lines.push("");
+  }
+  columns(left, right, { tone = "default" } = {}) {
+    const rightText = truncate(right, Math.max(0, this.width - 1));
+    const leftWidth = Math.max(0, this.width - textWidth(rightText) - 1);
+    const leftText = truncate(left, leftWidth);
+    const gap = Math.max(0, this.width - textWidth(leftText) - textWidth(rightText));
+    const line = `${leftText}${" ".repeat(gap)}${rightText}`;
+    this.lines.push(`${colors[tone]}${line}${AnsiCode.reset}`);
+  }
+  divider({ character = "-", tone = "default" } = {}) {
+    const token = Array.from(character)[0] ?? "-";
+    this.lines.push(`${colors[tone]}${token.repeat(this.width)}${AnsiCode.reset}`);
+  }
+  header(lines) {
+    const border = "#".repeat(this.width);
+    this.lines.push(border);
+    for (const line of lines) {
+      const innerWidth = Math.max(0, this.width - 2);
+      const truncated = truncate(line, innerWidth);
+      const content = truncated + " ".repeat(Math.max(0, innerWidth - textWidth(truncated)));
+      this.lines.push(`#${content}#`);
+    }
+    this.lines.push(border);
+  }
+  static renderFrame(ui) {
+    return `${ui.lines.join(`
+`)}
+`;
+  }
+}
+
+// node:string_decoder
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var require_safe_buffer = __commonJS((exports, module) => {
+  /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+  var buffer = (init_buffer(), __toCommonJS(exports_buffer)), Buffer3 = buffer.Buffer;
+  function copyProps(src, dst) {
+    for (var key in src)
+      dst[key] = src[key];
+  }
+  if (Buffer3.from && Buffer3.alloc && Buffer3.allocUnsafe && Buffer3.allocUnsafeSlow)
+    module.exports = buffer;
+  else
+    copyProps(buffer, exports), exports.Buffer = SafeBuffer;
+  function SafeBuffer(arg, encodingOrOffset, length) {
+    return Buffer3(arg, encodingOrOffset, length);
+  }
+  SafeBuffer.prototype = Object.create(Buffer3.prototype);
+  copyProps(Buffer3, SafeBuffer);
+  SafeBuffer.from = function(arg, encodingOrOffset, length) {
+    if (typeof arg === "number")
+      throw TypeError("Argument must not be a number");
+    return Buffer3(arg, encodingOrOffset, length);
+  };
+  SafeBuffer.alloc = function(size, fill, encoding) {
+    if (typeof size !== "number")
+      throw TypeError("Argument must be a number");
+    var buf = Buffer3(size);
+    if (fill !== undefined)
+      if (typeof encoding === "string")
+        buf.fill(fill, encoding);
+      else
+        buf.fill(fill);
+    else
+      buf.fill(0);
+    return buf;
+  };
+  SafeBuffer.allocUnsafe = function(size) {
+    if (typeof size !== "number")
+      throw TypeError("Argument must be a number");
+    return Buffer3(size);
+  };
+  SafeBuffer.allocUnsafeSlow = function(size) {
+    if (typeof size !== "number")
+      throw TypeError("Argument must be a number");
+    return buffer.SlowBuffer(size);
+  };
+});
+var Buffer3 = require_safe_buffer().Buffer;
+var isEncoding = Buffer3.isEncoding || function(encoding) {
+  switch (encoding = "" + encoding, encoding && encoding.toLowerCase()) {
+    case "hex":
+    case "utf8":
+    case "utf-8":
+    case "ascii":
+    case "binary":
+    case "base64":
+    case "ucs2":
+    case "ucs-2":
+    case "utf16le":
+    case "utf-16le":
+    case "raw":
+      return true;
+    default:
+      return false;
+  }
+};
+function _normalizeEncoding(enc) {
+  if (!enc)
+    return "utf8";
+  var retried;
+  while (true)
+    switch (enc) {
+      case "utf8":
+      case "utf-8":
+        return "utf8";
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return "utf16le";
+      case "latin1":
+      case "binary":
+        return "latin1";
+      case "base64":
+      case "ascii":
+      case "hex":
+        return enc;
+      default:
+        if (retried)
+          return;
+        enc = ("" + enc).toLowerCase(), retried = true;
+    }
+}
+function normalizeEncoding(enc) {
+  var nenc = _normalizeEncoding(enc);
+  if (typeof nenc !== "string" && (Buffer3.isEncoding === isEncoding || !isEncoding(enc)))
+    throw Error("Unknown encoding: " + enc);
+  return nenc || enc;
+}
+var $StringDecoder = StringDecoder;
+function StringDecoder(encoding) {
+  this.encoding = normalizeEncoding(encoding);
+  var nb;
+  switch (this.encoding) {
+    case "utf16le":
+      this.text = utf16Text, this.end = utf16End, nb = 4;
+      break;
+    case "utf8":
+      this.fillLast = utf8FillLast, nb = 4;
+      break;
+    case "base64":
+      this.text = base64Text, this.end = base64End, nb = 3;
+      break;
+    default:
+      this.write = simpleWrite, this.end = simpleEnd;
+      return;
+  }
+  this.lastNeed = 0, this.lastTotal = 0, this.lastChar = Buffer3.allocUnsafe(nb);
+}
+StringDecoder.prototype.write = function(buf) {
+  if (buf.length === 0)
+    return "";
+  var r, i2;
+  if (this.lastNeed) {
+    if (r = this.fillLast(buf), r === undefined)
+      return "";
+    i2 = this.lastNeed, this.lastNeed = 0;
+  } else
+    i2 = 0;
+  if (i2 < buf.length)
+    return r ? r + this.text(buf, i2) : this.text(buf, i2);
+  return r || "";
+};
+StringDecoder.prototype.end = utf8End;
+StringDecoder.prototype.text = utf8Text;
+StringDecoder.prototype.fillLast = function(buf) {
+  if (this.lastNeed <= buf.length)
+    return buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length), this.lastNeed -= buf.length;
+};
+function utf8CheckByte(byte) {
+  if (byte <= 127)
+    return 0;
+  else if (byte >> 5 === 6)
+    return 2;
+  else if (byte >> 4 === 14)
+    return 3;
+  else if (byte >> 3 === 30)
+    return 4;
+  return byte >> 6 === 2 ? -1 : -2;
+}
+function utf8CheckIncomplete(self, buf, i2) {
+  var j = buf.length - 1;
+  if (j < i2)
+    return 0;
+  var nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0)
+      self.lastNeed = nb - 1;
+    return nb;
+  }
+  if (--j < i2 || nb === -2)
+    return 0;
+  if (nb = utf8CheckByte(buf[j]), nb >= 0) {
+    if (nb > 0)
+      self.lastNeed = nb - 2;
+    return nb;
+  }
+  if (--j < i2 || nb === -2)
+    return 0;
+  if (nb = utf8CheckByte(buf[j]), nb >= 0) {
+    if (nb > 0)
+      if (nb === 2)
+        nb = 0;
+      else
+        self.lastNeed = nb - 3;
+    return nb;
+  }
+  return 0;
+}
+function utf8CheckExtraBytes(self, buf, p) {
+  if ((buf[0] & 192) !== 128)
+    return self.lastNeed = 0, "�";
+  if (self.lastNeed > 1 && buf.length > 1) {
+    if ((buf[1] & 192) !== 128)
+      return self.lastNeed = 1, "�";
+    if (self.lastNeed > 2 && buf.length > 2) {
+      if ((buf[2] & 192) !== 128)
+        return self.lastNeed = 2, "�";
+    }
+  }
+}
+function utf8FillLast(buf) {
+  var p = this.lastTotal - this.lastNeed, r = utf8CheckExtraBytes(this, buf, p);
+  if (r !== undefined)
+    return r;
+  if (this.lastNeed <= buf.length)
+    return buf.copy(this.lastChar, p, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  buf.copy(this.lastChar, p, 0, buf.length), this.lastNeed -= buf.length;
+}
+function utf8Text(buf, i2) {
+  var total = utf8CheckIncomplete(this, buf, i2);
+  if (!this.lastNeed)
+    return buf.toString("utf8", i2);
+  this.lastTotal = total;
+  var end = buf.length - (total - this.lastNeed);
+  return buf.copy(this.lastChar, 0, end), buf.toString("utf8", i2, end);
+}
+function utf8End(buf) {
+  var r = buf && buf.length ? this.write(buf) : "";
+  if (this.lastNeed)
+    return r + "�";
+  return r;
+}
+function utf16Text(buf, i2) {
+  if ((buf.length - i2) % 2 === 0) {
+    var r = buf.toString("utf16le", i2);
+    if (r) {
+      var c = r.charCodeAt(r.length - 1);
+      if (c >= 55296 && c <= 56319)
+        return this.lastNeed = 2, this.lastTotal = 4, this.lastChar[0] = buf[buf.length - 2], this.lastChar[1] = buf[buf.length - 1], r.slice(0, -1);
+    }
+    return r;
+  }
+  return this.lastNeed = 1, this.lastTotal = 2, this.lastChar[0] = buf[buf.length - 1], buf.toString("utf16le", i2, buf.length - 1);
+}
+function utf16End(buf) {
+  var r = buf && buf.length ? this.write(buf) : "";
+  if (this.lastNeed) {
+    var end = this.lastTotal - this.lastNeed;
+    return r + this.lastChar.toString("utf16le", 0, end);
+  }
+  return r;
+}
+function base64Text(buf, i2) {
+  var n = (buf.length - i2) % 3;
+  if (n === 0)
+    return buf.toString("base64", i2);
+  if (this.lastNeed = 3 - n, this.lastTotal = 3, n === 1)
+    this.lastChar[0] = buf[buf.length - 1];
+  else
+    this.lastChar[0] = buf[buf.length - 2], this.lastChar[1] = buf[buf.length - 1];
+  return buf.toString("base64", i2, buf.length - n);
+}
+function base64End(buf) {
+  var r = buf && buf.length ? this.write(buf) : "";
+  if (this.lastNeed)
+    return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+  return r;
+}
+function simpleWrite(buf) {
+  return buf.toString(this.encoding);
+}
+function simpleEnd(buf) {
+  return buf && buf.length ? this.write(buf) : "";
+}
+
+// src/input/terminal-events.ts
+var noModifiers = {
+  ctrl: false,
+  shift: false,
+  alt: false
+};
+function createNamedEvent(key, sequence, modifiers = {}) {
+  return { key, ...noModifiers, ...modifiers, sequence };
+}
+function createTextEvent(text, sequence, modifiers = {}) {
+  return { key: "text", text, ...noModifiers, ...modifiers, sequence };
+}
+
+// src/input/terminal-parsers.ts
+var controlKeys = {
+  "\r": "enter",
+  "\n": "enter",
+  "\t": "tab",
+  "": "backspace",
+  "\b": "backspace"
+};
+var arrowKeys = {
+  A: "up",
+  B: "down",
+  C: "right",
+  D: "left"
+};
+function parseInput(value) {
+  const character = Array.from(value)[0];
+  if (!character) {
+    return;
+  }
+  const controlKey = controlKeys[character];
+  if (controlKey) {
+    return parsed(createNamedEvent(controlKey, character));
+  }
+  if (character === "\x1B") {
+    return parseEscapeSequence(value);
+  }
+  const code2 = character.charCodeAt(0);
+  if (code2 >= 1 && code2 <= 26) {
+    return parsed(createTextEvent(String.fromCharCode(code2 + 96), character, { ctrl: true }));
+  }
+  return charIsPrintable(character) ? parsed(createTextEvent(character, character)) : parsed(createNamedEvent("unknown", character));
+}
+function parseEscapeSequence(value) {
+  if (value.length === 1) {
+    return;
+  }
+  const prefix = value.charAt(1);
+  if (prefix !== "[" && prefix !== "O") {
+    const character = Array.from(value.slice(1))[0];
+    if (!character) {
+      return;
+    }
+    if (character === "\x1B") {
+      return parsed(createNamedEvent("escape", "\x1B"));
+    }
+    const sequence2 = value.slice(0, 1 + character.length);
+    return charIsPrintable(character) ? parsed(createTextEvent(character, sequence2, { alt: true })) : parsed(createNamedEvent("unknown", sequence2, { alt: true }));
+  }
+  const match = /^\x1b(?:O(.)|\[([0-9;]*)([A-Za-z~]))/.exec(value);
+  if (!match) {
+    return;
+  }
+  const sequence = match[0];
+  const final = match[1] ?? match[3] ?? "";
+  const key = arrowKeys[final] ?? "unknown";
+  const modifiers = prefix === "[" ? parseCsiModifiers(match[2] ?? "") : {};
+  return parsed(createNamedEvent(key, sequence, modifiers));
+}
+function parseCsiModifiers(params) {
+  const modifier = Number(params.split(";").filter(Boolean).at(-1));
+  const mask = modifier >= 2 && modifier <= 8 ? modifier - 1 : 0;
+  return {
+    shift: (mask & 1) !== 0,
+    alt: (mask & 2) !== 0,
+    ctrl: (mask & 4) !== 0
+  };
+}
+function parsed(event) {
+  return { event, consumed: event.sequence.length };
+}
+function charIsPrintable(character) {
+  const code2 = character.charCodeAt(0);
+  return code2 >= 32 && code2 !== 127;
+}
+
+// src/input/terminal-input.ts
+var ESCAPE_DELAY_MS = 25;
+
+class TerminalInput {
+  input;
+  onKey;
+  pending = "";
+  pendingEscapeTimeout;
+  wasRaw = false;
+  wasFlowing = false;
+  decoder = new $StringDecoder("utf8");
+  constructor(input = process.stdin) {
+    this.input = input;
+  }
+  start(onKey) {
+    if (this.onKey) {
+      return;
+    }
+    this.onKey = onKey;
+    this.decoder = new $StringDecoder("utf8");
+    this.wasFlowing = this.input.readableFlowing === true;
+    if (this.input.isTTY) {
+      this.wasRaw = !!this.input.isRaw;
+      this.input.setRawMode(true);
+    }
+    this.input.resume();
+    this.input.on("data", this.handleData);
+  }
+  stop() {
+    if (!this.onKey) {
+      return;
+    }
+    this.input.off("data", this.handleData);
+    if (this.input.isTTY) {
+      this.input.setRawMode(this.wasRaw);
+    }
+    if (this.wasFlowing) {
+      this.input.resume();
+    } else {
+      this.input.pause();
+    }
+    this.onKey = undefined;
+    this.pending = "";
+    this.clearEscapeTimeout();
+  }
+  handleData = (chunk) => {
+    this.pending += this.decoder.write(Buffer.from(chunk));
+    this.clearEscapeTimeout();
+    while (this.pending) {
+      const parsed2 = parseInput(this.pending);
+      if (!parsed2) {
+        if (this.pending === "\x1B") {
+          this.waitForStandaloneEscape();
+        }
+        return;
+      }
+      this.pending = this.pending.slice(parsed2.consumed);
+      this.onKey?.(parsed2.event);
+    }
+  };
+  waitForStandaloneEscape() {
+    this.pendingEscapeTimeout = setTimeout(() => {
+      this.pendingEscapeTimeout = undefined;
+      if (this.pending !== "\x1B") {
+        return;
+      }
+      this.pending = "";
+      if (this.onKey) {
+        const namedEvent = createNamedEvent("escape", "\x1B");
+        this.onKey(namedEvent);
+      }
+    }, ESCAPE_DELAY_MS);
+  }
+  clearEscapeTimeout() {
+    if (this.pendingEscapeTimeout === undefined) {
+      return;
+    }
+    clearTimeout(this.pendingEscapeTimeout);
+    this.pendingEscapeTimeout = undefined;
+  }
+}
+
+// src/core/terminal-session.ts
+class TerminalSession {
+  input;
+  output;
+  handlers;
+  constructor(input, output = process.stdout) {
+    this.input = new TerminalInput(input);
+    this.output = output;
+  }
+  get width() {
+    return Math.max(1, process.stdout.columns ?? 80);
+  }
+  get height() {
+    return Math.max(1, process.stdout.rows ?? 24);
+  }
+  start(handlers) {
+    this.handlers = handlers;
+    this.output.write(AnsiCode.hideCursor);
+    this.input.start(handlers.key);
+    process.on("SIGINT", handlers.sigint);
+    process.stdout.on("resize", handlers.resize);
+  }
+  writeFrame(frame) {
+    this.output.write(`${AnsiCode.clear}${AnsiCode.reset}${frame}`);
+  }
+  stop() {
+    this.input.stop();
+    if (this.handlers) {
+      process.off("SIGINT", this.handlers.sigint);
+      process.stdout.off("resize", this.handlers.resize);
+      this.handlers = undefined;
+    }
+    this.output.write(`${AnsiCode.clear}${AnsiCode.reset}`);
+    this.output.write(AnsiCode.showCursor);
+    this.output.write(AnsiCode.reset);
+  }
+}
+
+// src/core/screen-stack-app.ts
+class ScreenStackApp {
+  options;
+  frameStack = [];
+  terminal;
+  runCompletion;
+  isRendering = false;
+  hasRenderRequest = false;
+  renderBatchDepth = 0;
+  constructor(userOptions) {
+    this.options = userOptions;
+    this.terminal = new TerminalSession(userOptions.input, userOptions.output);
+  }
+  get isRunning() {
+    return this.runCompletion !== undefined;
+  }
+  async run(root) {
+    if (this.runCompletion) {
+      throw new Error("This CLI app is already running.");
+    }
+    const completion = new Promise((resolve, reject) => {
+      this.runCompletion = {
+        resolve,
+        reject
+      };
+    });
+    try {
+      this.terminal.start({
+        key: this.handleKey,
+        resize: this.handleResize,
+        sigint: this.handleSigint
+      });
+      this.batchRender(() => this.mount(root));
+    } catch (error) {
+      this.stop({ error });
+    }
+    return completion;
+  }
+  dispose() {
+    this.stop({ result: undefined });
+  }
+  currentFrame() {
+    return this.frameStack.at(-1);
+  }
+  createFrame(screen, resolve) {
+    const controller = new AbortController;
+    let frame;
+    const navigation = {
+      push: (screen2) => this.pushFrame(frame, screen2),
+      back: (result) => this.back(frame, result),
+      replace: (screen2) => this.replace(frame, screen2),
+      reset: (screen2) => this.reset(frame, screen2),
+      exit: (result) => this.exit(frame, result)
+    };
+    frame = {
+      screen,
+      controller,
+      environment: {
+        context: this.options.context,
+        navigation,
+        signal: controller.signal,
+        requestRender: () => this.requestRender(frame)
+      },
+      resolve
+    };
+    return frame;
+  }
+  mount(screen, resolve) {
+    const frame = this.createFrame(screen, resolve);
+    this.frameStack.push(frame);
+    this.runLifecycleHook(frame, frame.screen.mount);
+    return frame;
+  }
+  requestRender(frame) {
+    if (!frame.controller.signal.aborted && frame === this.currentFrame()) {
+      this.render();
+    }
+  }
+  pushFrame(expected, screen) {
+    const parent = this.currentFrame();
+    if (!this.isRunning || !parent || expected !== parent) {
+      return Promise.resolve(undefined);
+    }
+    return this.batchRender(() => {
+      this.runLifecycleHook(parent, parent.screen.suspend);
+      return new Promise((resolve) => {
+        this.mount(screen, resolve);
+      });
+    });
+  }
+  back(expected, result) {
+    if (!this.runCompletion || expected !== this.currentFrame()) {
+      return;
+    }
+    if (this.frameStack.length === 1) {
+      this.stop({ result });
+      return;
+    }
+    this.batchRender(() => {
+      const closed = this.frameStack.pop();
+      this.unmount(closed);
+      closed.resolve?.(result);
+      const parent = this.currentFrame();
+      if (parent) {
+        this.runLifecycleHook(parent, parent.screen.resume);
+      }
+    });
+  }
+  replace(expected, screen) {
+    const current = this.currentFrame();
+    if (!this.runCompletion || expected !== current) {
+      return;
+    }
+    this.batchRender(() => {
+      const closed = this.frameStack.pop();
+      this.unmount(closed);
+      this.mount(screen, closed.resolve);
+    });
+  }
+  reset(expected, screen) {
+    const current = this.currentFrame();
+    if (!this.runCompletion || expected !== current) {
+      return;
+    }
+    this.batchRender(() => {
+      const oldFrames = this.frameStack.splice(0);
+      for (const frame of oldFrames.reverse()) {
+        this.unmount(frame);
+        frame.resolve?.(undefined);
+      }
+      this.mount(screen);
+    });
+  }
+  exit(expected, result) {
+    const current = this.currentFrame();
+    if (!this.runCompletion || expected !== current) {
+      return;
+    }
+    this.stop({ result });
+  }
+  render() {
+    const frame = this.currentFrame();
+    if (!this.runCompletion || !frame) {
+      return;
+    }
+    if (this.isRendering || this.renderBatchDepth > 0) {
+      this.hasRenderRequest = true;
+      return;
+    }
+    this.isRendering = true;
+    try {
+      const ui = new Ui(this.terminal.width, this.terminal.height);
+      const environment = {
+        ...frame.environment,
+        ui
+      };
+      frame.screen.render(environment);
+      this.terminal.writeFrame(Ui.renderFrame(ui));
+    } catch (error) {
+      this.reportError(error);
+    } finally {
+      this.isRendering = false;
+      if (this.hasRenderRequest) {
+        this.hasRenderRequest = false;
+        queueMicrotask(() => this.render());
+      }
+    }
+  }
+  batchRender(callback) {
+    this.renderBatchDepth += 1;
+    try {
+      return callback();
+    } finally {
+      this.renderBatchDepth -= 1;
+      if (this.renderBatchDepth === 0 && this.runCompletion) {
+        this.hasRenderRequest = false;
+        this.render();
+      }
+    }
+  }
+  handleKey = (event) => {
+    if (!this.runCompletion)
+      return;
+    if (event.key === "text" && event.ctrl && event.text === "c") {
+      this.stop({ result: undefined });
+      return;
+    }
+    const frame = this.currentFrame();
+    if (!frame?.screen.key)
+      return;
+    try {
+      frame.screen.key(event, frame.environment);
+    } catch (error) {
+      this.reportError(error);
+    }
+  };
+  handleSigint = () => {
+    this.stop({ result: undefined });
+  };
+  handleResize = () => {
+    this.render();
+  };
+  runLifecycleHook(frame, hook) {
+    if (!hook) {
+      return;
+    }
+    try {
+      const pending = hook.call(frame.screen, frame.environment);
+      if (pending) {
+        Promise.resolve(pending).catch((error) => this.reportError(error));
+      }
+    } catch (error) {
+      this.reportError(error);
+    }
+  }
+  unmount(frame, duringCleanup = false) {
+    if (frame.controller.signal.aborted) {
+      return;
+    }
+    frame.controller.abort();
+    try {
+      frame.screen.unmount?.call(frame.screen, frame.environment);
+    } catch (error) {
+      if (!duringCleanup) {
+        this.reportError(error);
+        return;
+      }
+      return this.reportCleanupError(error);
+    }
+  }
+  reportError(error) {
+    if (this.options.onError) {
+      try {
+        this.options.onError(error);
+      } catch (handlerError) {
+        this.stop({ error: handlerError });
+      }
+      return;
+    }
+    this.stop({ error });
+  }
+  reportCleanupError(error) {
+    if (!this.options.onError)
+      return error;
+    try {
+      this.options.onError(error);
+    } catch (handlerError) {
+      return handlerError;
+    }
+  }
+  stop(outcome) {
+    const activeRun = this.runCompletion;
+    if (!activeRun) {
+      return;
+    }
+    this.runCompletion = undefined;
+    const cleanupError = this.cleanupFrames();
+    let terminalError;
+    try {
+      this.terminal.stop();
+    } catch (error) {
+      terminalError = error;
+    }
+    if ("error" in outcome) {
+      activeRun.reject(outcome.error);
+    } else if (cleanupError !== undefined) {
+      activeRun.reject(cleanupError);
+    } else if (terminalError !== undefined) {
+      activeRun.reject(terminalError);
+    } else {
+      activeRun.resolve(outcome.result);
+    }
+  }
+  cleanupFrames() {
+    let firstError;
+    const oldFrames = this.frameStack.splice(0);
+    for (const frame of oldFrames.reverse()) {
+      const error = this.unmount(frame, true);
+      firstError ??= error;
+      frame.resolve?.(undefined);
+    }
+    return firstError;
+  }
+}
+
+// src/cli-app.ts
+function createCli(options) {
+  const resolvedOptions = options ?? { context: undefined };
+  return new ScreenStackApp(resolvedOptions);
+}
+// src/screen/screen.ts
+function defineScreen(screen) {
+  return screen;
+}
+// src/renderer/text-content.ts
+function normalizeText(content, defaults = {}) {
+  return typeof content === "string" ? { align: "left", tone: "default", ...defaults, value: content } : { align: "left", tone: "default", ...defaults, ...content };
+}
+function renderText(ui, content, defaults) {
+  const { value, tone, align } = normalizeText(content, defaults);
+  const aligned = alignText(value, align, ui.width);
+  ui.text(aligned, { tone });
+}
+function alignText(value, alignment, width) {
+  return value.split(`
+`).map((line) => `${alignmentPadding(line, alignment, width)}${line}`).join(`
+`);
+}
+function alignmentPadding(completeLine, alignment, width) {
+  const available = Math.max(0, width - textWidth(completeLine));
+  const padding = alignment === "center" ? Math.floor(available / 2) : alignment === "right" ? available : 0;
+  return " ".repeat(padding);
+}
+
+// src/screen/select.ts
+function select(options) {
+  let selectedIndex = findEnabled(options.choices, options.initialIndex ?? 0, 1);
+  let windowStart = 0;
+  return defineScreen({
+    render({ ui }) {
+      if (options.title) {
+        renderText(ui, options.title, { tone: "accent" });
+        ui.blank();
+      }
+      const subtitleText = options.subtitle ?? "Use ↑/↓ to move, Enter to select.";
+      renderText(ui, subtitleText, { tone: "muted" });
+      ui.blank();
+      const titleRows = options.title ? normalizeText(options.title).value.split(`
+`).length + 1 : 0;
+      const subtitleRows = normalizeText(subtitleText).value.split(`
+`).length + 1;
+      const viewport = getViewport(options.choices, selectedIndex, windowStart, Math.max(1, ui.height - titleRows - subtitleRows), options.maxVisible);
+      windowStart = viewport.start;
+      if (viewport.start > 0) {
+        ui.text(`  ↑ ${viewport.start} more`, { tone: "muted" });
+      }
+      for (let index = viewport.start;index < viewport.end; index++) {
+        const choice = options.choices[index];
+        const marker = index === selectedIndex ? "> " : "  ";
+        const suffix = choice.disabled ? " (unavailable)" : "";
+        const label = normalizeText(choice.label);
+        renderText(ui, {
+          value: `${marker}${label.value}${suffix}`,
+          align: label.align,
+          tone: index === selectedIndex ? "accent" : choice.disabled ? "muted" : label.tone
+        });
+        if (choice.description) {
+          const description = normalizeText(choice.description, { tone: "muted" });
+          renderText(ui, {
+            ...description,
+            value: `    ${description.value}`
+          });
+        }
+      }
+      const remaining = options.choices.length - viewport.end;
+      if (remaining > 0) {
+        ui.text(`  ↓ ${remaining} more`, { tone: "muted" });
+      }
+    },
+    key(event, { navigation, requestRender }) {
+      const cancelKeys = options.cancelKeys ?? ["escape", "backspace"];
+      if (cancelKeys.includes(event.key)) {
+        navigation.back();
+        return;
+      }
+      if (event.key === "enter") {
+        const selected = options.choices[selectedIndex];
+        if (selected && !selected.disabled) {
+          navigation.back(selected.value);
+        }
+        return;
+      }
+      const direction = event.key === "up" ? -1 : event.key === "down" ? 1 : 0;
+      if (direction === 0 || options.choices.length === 0) {
+        return;
+      }
+      const next = move(options.choices, selectedIndex, direction, options.loop ?? true);
+      if (next !== selectedIndex) {
+        selectedIndex = next;
+        requestRender();
+      }
+    }
+  });
+}
+function getViewport(choices, selectedIndex, requestedStart, availableRows, maxVisible = Number.POSITIVE_INFINITY) {
+  if (choices.length === 0)
+    return { start: 0, end: 0 };
+  let start = Math.max(0, Math.min(requestedStart, choices.length - 1));
+  if (selectedIndex >= 0 && selectedIndex < start) {
+    start = selectedIndex;
+  }
+  let end = viewportEnd(choices, start, availableRows, maxVisible);
+  while (selectedIndex >= end && start < selectedIndex) {
+    start += 1;
+    end = viewportEnd(choices, start, availableRows, maxVisible);
+  }
+  return { start, end };
+}
+function viewportEnd(choices, start, availableRows, maxVisible) {
+  let rowsUsed = start > 0 ? 1 : 0;
+  let end = start;
+  let visibleCount = 0;
+  const choiceLimit = Math.max(1, maxVisible);
+  while (end < choices.length && visibleCount < choiceLimit) {
+    const choiceRows = choices[end]?.description ? 2 : 1;
+    const bottomIndicatorRows = end + 1 < choices.length ? 1 : 0;
+    if (end > start && rowsUsed + choiceRows + bottomIndicatorRows > availableRows) {
+      break;
+    }
+    rowsUsed += choiceRows;
+    end += 1;
+    visibleCount += 1;
+  }
+  return Math.max(start + 1, end);
+}
+function findEnabled(choices, requestedIndex, direction) {
+  if (choices.length === 0) {
+    return -1;
+  }
+  const start = Math.min(Math.max(0, requestedIndex), choices.length - 1);
+  for (let offset = 0;offset < choices.length; offset++) {
+    const index = (start + offset * direction + choices.length) % choices.length;
+    if (!choices[index]?.disabled) {
+      return index;
+    }
+  }
+  return -1;
+}
+function move(choices, current, direction, loop) {
+  if (current < 0) {
+    return findEnabled(choices, 0, 1);
+  }
+  let index = current;
+  for (let count = 0;count < choices.length; count++) {
+    const candidate = index + direction;
+    if (!loop && (candidate < 0 || candidate >= choices.length)) {
+      return current;
+    }
+    index = (candidate + choices.length) % choices.length;
+    if (!choices[index]?.disabled) {
+      return index;
+    }
+  }
+  return current;
+}
+
+// src/screen/menu.ts
+var backAction = Symbol("back");
+function menu(options) {
+  const choices = options.backLabel === false ? options.choices : [
+    ...options.choices,
+    { label: options.backLabel ?? "Back", value: backAction }
+  ];
+  const selection = select({
+    ...options,
+    choices
+  });
+  return defineScreen({
+    render(environment) {
+      selection.render(environment);
+    },
+    key(event, environment) {
+      let selected;
+      const proxy = {
+        ...environment,
+        navigation: {
+          ...environment.navigation,
+          back(value) {
+            if (value !== undefined) {
+              selected = value;
+            } else {
+              environment.navigation.back();
+            }
+          }
+        }
+      };
+      selection.key?.(event, proxy);
+      if (selected === backAction) {
+        environment.navigation.back();
+      } else if (selected !== undefined) {
+        options.onSelect(selected, environment);
+      }
+    }
+  });
+}
+// src/screen/message.ts
+function message(options) {
+  const settings = typeof options === "string" || "value" in options ? { text: options } : options;
+  const dismissKeys = settings.dismissKeys ?? ["enter", "escape", "backspace"];
+  return defineScreen({
+    render({ ui }) {
+      if (settings.title) {
+        renderText(ui, settings.title, { tone: "accent" });
+        ui.blank();
+      }
+      renderText(ui, settings.text);
+      ui.blank();
+      renderText(ui, settings.hint ?? "Press Enter to return.", { tone: "muted" });
+    },
+    key(event, { navigation }) {
+      if (dismissKeys.includes("any") || dismissKeys.includes(event.key)) {
+        navigation.back();
+      }
+    }
+  });
+}
+// src/screen/sequence.ts
+function sequence(sources) {
+  return defineScreen({
+    async mount({ navigation, signal }) {
+      for (const source of sources) {
+        if (signal.aborted) {
+          return;
+        }
+        const screen = typeof source === "function" ? source() : source;
+        await navigation.push(screen);
+      }
+      if (!signal.aborted) {
+        navigation.back();
+      }
+    },
+    render() {}
+  });
+}
+// src/screen/text-input.ts
+function textInput(options = {}) {
+  let value = options.initialValue ?? "";
+  let cursor = Array.from(value).length;
+  let error;
+  return defineScreen({
+    render({ ui }) {
+      renderText(ui, options.message ?? "Enter a value, then press Enter.");
+      ui.blank();
+      const mask = typeof options.mask === "string" ? options.mask : "*";
+      const characters = Array.from(value);
+      const visibleCharacters = options.mask ? characters.map(() => mask) : characters;
+      let input;
+      if (visibleCharacters.length === 0) {
+        input = normalizeText(options.placeholder ?? "│", { tone: "muted" });
+      } else {
+        const beforeCursor = visibleCharacters.slice(0, cursor).join("");
+        const afterCursor = visibleCharacters.slice(cursor).join("");
+        input = {
+          value: `${beforeCursor}│${afterCursor}`,
+          align: "left",
+          tone: "accent"
+        };
+      }
+      renderText(ui, {
+        ...input,
+        value: `> ${input.value}`
+      });
+      if (error) {
+        ui.blank();
+        renderText(ui, error, { tone: "accent" });
+      }
+    },
+    key(event, { navigation, requestRender }) {
+      if (event.key === "escape" && (options.cancelKeys ?? ["escape"]).includes("escape")) {
+        navigation.back();
+        return;
+      }
+      if (event.key === "enter") {
+        error = !options.allowEmpty && value.length === 0 ? "A value is required." : options.validate?.(value);
+        if (error) {
+          requestRender();
+        } else {
+          navigation.back(value);
+        }
+        return;
+      }
+      if (event.key === "backspace") {
+        const characters = Array.from(value);
+        if (cursor > 0) {
+          characters.splice(cursor - 1, 1);
+          cursor -= 1;
+          value = characters.join("");
+        }
+        error = undefined;
+        requestRender();
+        return;
+      }
+      if (event.key === "left" || event.key === "right") {
+        const change = event.key === "left" ? -1 : 1;
+        cursor = Math.max(0, Math.min(Array.from(value).length, cursor + change));
+        requestRender();
+        return;
+      }
+      if (event.key === "text" && !event.ctrl && !event.alt) {
+        const characters = Array.from(value);
+        const inserted = Array.from(event.text);
+        characters.splice(cursor, 0, ...inserted);
+        cursor += inserted.length;
+        value = characters.join("");
+        error = undefined;
+        requestRender();
+      }
+    }
+  });
+}
+// src/screen/typewriter.ts
+function typewriter(options) {
+  const title = options.title === undefined ? undefined : normalizeText(options.title);
+  const body = normalizeText(options.text);
+  const characters = Array.from(body.value);
+  const speed = Math.max(1, options.charactersPerSecond ?? 30);
+  let visibleCount = 0;
+  let timer;
+  return defineScreen({
+    mount({ requestRender, navigation, signal }) {
+      if (characters.length === 0) {
+        if (options.autoDismiss) {
+          navigation.back();
+        }
+        return;
+      }
+      const delay = Math.max(1, Math.round(1000 / speed));
+      timer = setInterval(() => {
+        visibleCount = Math.min(characters.length, visibleCount + 1);
+        requestRender();
+        if (visibleCount === characters.length && timer) {
+          clearInterval(timer);
+          timer = undefined;
+          if (options.autoDismiss) {
+            navigation.back();
+          }
+        }
+      }, delay);
+      signal.addEventListener("abort", () => {
+        if (timer) {
+          clearInterval(timer);
+        }
+        timer = undefined;
+      }, { once: true });
+    },
+    render({ ui }) {
+      if (title) {
+        const titleContent = alignText(title.value, title.align, ui.width);
+        ui.text(titleContent, { tone: title.tone });
+        ui.blank();
+      }
+      const bodyContent = alignAnimatedText(body.value, visibleCount, body.align, ui.width);
+      ui.text(bodyContent, { tone: body.tone });
+      if (visibleCount === characters.length && !options.autoDismiss) {
+        ui.blank();
+        const dismissText = alignText("Press Enter to return.", body.align, ui.width);
+        ui.text(dismissText);
+      }
+    },
+    key(event, { navigation, requestRender }) {
+      if (options.autoDismiss) {
+        return;
+      }
+      if (visibleCount < characters.length) {
+        visibleCount = characters.length;
+        if (timer) {
+          clearInterval(timer);
+        }
+        timer = undefined;
+        requestRender();
+        return;
+      }
+      if (visibleCount === characters.length && (event.key === "enter" || event.key === "escape" || event.key === "backspace")) {
+        navigation.back();
+      }
+    }
+  });
+}
+function alignAnimatedText(completeText, visibleCount, alignment, width) {
+  const completeLines = completeText.split(`
+`);
+  const visibleLines = Array.from(completeText).slice(0, visibleCount).join("").split(`
+`);
+  return visibleLines.map((line, index) => {
+    const completeLine = completeLines[index] ?? "";
+    return `${alignmentPadding(completeLine, alignment, width)}${line}`;
+  }).join(`
+`);
+}
+// src/screen/with-task.ts
+function withTask(screen, task) {
+  let screenEnvironment;
+  return defineScreen({
+    async mount(environment) {
+      screenEnvironment = decorateEnvironment(environment);
+      const visualMount = Promise.resolve(screen.mount?.(screenEnvironment));
+      const taskResult = Promise.resolve().then(() => task({
+        context: environment.context,
+        signal: environment.signal
+      }));
+      const visualMountFailure = visualMount.then(() => new Promise(() => {}), (error) => Promise.reject(error));
+      const result = await Promise.race([taskResult, visualMountFailure]);
+      if (!environment.signal.aborted) {
+        environment.navigation.back(result);
+      }
+    },
+    render(environment) {
+      const decorated = screenEnvironment ?? decorateEnvironment(environment);
+      const renderEnvironment = {
+        ...decorated,
+        ui: environment.ui
+      };
+      screen.render(renderEnvironment);
+    },
+    key(event) {
+      if (screenEnvironment) {
+        screen.key?.(event, screenEnvironment);
+      }
+    },
+    suspend() {
+      if (screenEnvironment) {
+        screen.suspend?.(screenEnvironment);
+      }
+    },
+    resume() {
+      if (screenEnvironment) {
+        screen.resume?.(screenEnvironment);
+      }
+    },
+    unmount() {
+      if (screenEnvironment) {
+        screen.unmount?.(screenEnvironment);
+      }
+    }
+  });
+}
+function decorateEnvironment(environment) {
+  const navigation = {
+    ...environment.navigation,
+    back() {},
+    replace() {},
+    reset() {},
+    exit() {}
+  };
+  return {
+    ...environment,
+    navigation
+  };
+}
+export {
+  withTask,
+  typewriter,
+  textInput,
+  sequence,
+  select,
+  message,
+  menu,
+  defineScreen,
+  createCli,
+  Ui
+};