@opentui/core 0.5.0 → 0.5.2

package/{chunk-node-savhj5rp.js → chunk-node-aj3n20gq.js}

@@ -8862,6 +8862,13 @@ class TreeSitterClient extends EventEmitter2 {
         return;
       }
       case "ERROR": {
+        if (message.messageId) {
+          const callback = this.messageCallbacks.get(message.messageId);
+          if (callback) {
+            this.messageCallbacks.delete(message.messageId);
+            callback.reject(new Error(message.error));
+          }
+        }
         this.emitError(message.error, message.bufferId);
         return;
       }
@@ -10527,7 +10534,575 @@ function decodePasteBytes(bytes) {
 function stripAnsiSequences(text) {
   return stripANSI(text);
 }
+// src/lib/host-clipboard.internal.ts
+var DEFAULT_CLIPBOARD_TIMEOUT_MS = 1000;
+var DEFAULT_CLIPBOARD_MAX_BYTES = 8 * 1024 * 1024;
+var DEFAULT_CLIPBOARD_MAX_IMAGE_PIXELS = 64 * 1024 * 1024;
+var DEFAULT_CLIPBOARD_MAX_CONVERSION_BYTES = 512 * 1024 * 1024;
+var DEFAULT_CLIPBOARD_MAX_CONCURRENT_OPERATIONS = 16;
+var DEFAULT_CLIPBOARD_MAX_PROVIDER_TRANSFERS = 16;
+var MAX_U32 = 4294967295;
+var MIME_ESSENCE_PATTERN = /^[a-z0-9!#$%&'*+.^_`|~-]+\/[a-z0-9!#$%&'*+.^_`|~-]+$/i;
+var HOST_CLIPBOARD_MIME_PREFERENCE_COUNT_MAX = 64;
+var HOST_CLIPBOARD_MIME_ESSENCE_BYTES_MAX = 255;
+var validateU32 = (name, value) => {
+  if (!Number.isInteger(value) || value < 0 || value > MAX_U32) {
+    throw new RangeError(`${name} must be an integer from 0 through ${MAX_U32}`);
+  }
+  return value;
+};
+var validatePositiveU32 = (name, value) => {
+  const validated = validateU32(name, value);
+  if (validated === 0)
+    throw new RangeError(`${name} must be greater than zero`);
+  return validated;
+};
+var normalizeOptions = (options) => {
+  const waylandSeat = options.waylandSeat;
+  if (waylandSeat !== undefined && (typeof waylandSeat !== "string" || waylandSeat.length === 0 || waylandSeat.includes("\x00"))) {
+    throw new TypeError("waylandSeat must be a non-empty string without NUL characters");
+  }
+  return {
+    timeoutMs: validateU32("timeoutMs", options.timeoutMs ?? DEFAULT_CLIPBOARD_TIMEOUT_MS),
+    maxReadBytes: validateU32("maxReadBytes", options.maxReadBytes ?? DEFAULT_CLIPBOARD_MAX_BYTES),
+    maxWriteBytes: validateU32("maxWriteBytes", options.maxWriteBytes ?? DEFAULT_CLIPBOARD_MAX_BYTES),
+    maxImagePixels: validateU32("maxImagePixels", options.maxImagePixels ?? DEFAULT_CLIPBOARD_MAX_IMAGE_PIXELS),
+    maxConversionBytes: validateU32("maxConversionBytes", options.maxConversionBytes ?? DEFAULT_CLIPBOARD_MAX_CONVERSION_BYTES),
+    maxConcurrentOperations: validatePositiveU32("maxConcurrentOperations", options.maxConcurrentOperations ?? DEFAULT_CLIPBOARD_MAX_CONCURRENT_OPERATIONS),
+    maxProviderTransfers: validatePositiveU32("maxProviderTransfers", options.maxProviderTransfers ?? DEFAULT_CLIPBOARD_MAX_PROVIDER_TRANSFERS),
+    waylandSeat
+  };
+};
+var normalizePreferredTypes = (preferredTypes) => {
+  if (!Array.isArray(preferredTypes) || preferredTypes.length === 0) {
+    throw new TypeError("preferredTypes must contain at least one MIME essence type");
+  }
+  if (preferredTypes.length > HOST_CLIPBOARD_MIME_PREFERENCE_COUNT_MAX) {
+    throw new RangeError(`preferredTypes must contain at most ${HOST_CLIPBOARD_MIME_PREFERENCE_COUNT_MAX} MIME essence types`);
+  }
+  const normalized = preferredTypes.map((mimeType) => {
+    if (typeof mimeType !== "string") {
+      throw new TypeError("preferredTypes must contain valid MIME essence types without parameters");
+    }
+    if (mimeType.length > HOST_CLIPBOARD_MIME_ESSENCE_BYTES_MAX) {
+      throw new RangeError(`preferredTypes MIME essences must be at most ${HOST_CLIPBOARD_MIME_ESSENCE_BYTES_MAX} ASCII bytes`);
+    }
+    if (!MIME_ESSENCE_PATTERN.test(mimeType)) {
+      throw new TypeError("preferredTypes must contain valid MIME essence types without parameters");
+    }
+    return mimeType.toLowerCase();
+  });
+  return normalized;
+};
+var normalizeSelection = (selection) => {
+  const normalized = selection ?? "clipboard";
+  if (normalized !== "clipboard" && normalized !== "primary") {
+    throw new TypeError("selection must be clipboard or primary");
+  }
+  return normalized;
+};
+var validateClipboardText = (text, maxWriteBytes) => {
+  if (typeof text !== "string" || text.length === 0)
+    throw new TypeError("writeText requires non-empty text");
+  if (text.includes("\x00"))
+    throw new TypeError("writeText does not support NUL characters");
+  const byteLimit = Math.min(maxWriteBytes, MAX_U32);
+  let byteLength = 0;
+  for (const character of text) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint >= 55296 && codePoint <= 57343) {
+      throw new TypeError("writeText does not support unpaired UTF-16 surrogates");
+    }
+    if (codePoint <= 127) {
+      byteLength += 1;
+    } else if (codePoint <= 2047) {
+      byteLength += 2;
+    } else if (codePoint <= 65535) {
+      byteLength += 3;
+    } else {
+      byteLength += 4;
+    }
+    if (byteLength > byteLimit) {
+      throw new RangeError(`writeText exceeds the configured ${maxWriteBytes} byte limit`);
+    }
+  }
+};
+var createActiveOperation = (callerSignal) => {
+  const controller = new AbortController;
+  let settle = () => {};
+  const settled = new Promise((resolve3) => {
+    settle = resolve3;
+  });
+  if (callerSignal) {
+    callerSignal.addEventListener("abort", () => controller.abort(callerSignal.reason), {
+      once: true,
+      signal: controller.signal
+    });
+  }
+  return { controller, settled, settle };
+};
+var runTrackedOperation = (active, callerSignal, operation) => {
+  const state = createActiveOperation(callerSignal);
+  active.add(state);
+  let result;
+  try {
+    result = operation(state.controller.signal);
+  } catch (error) {
+    result = Promise.reject(error);
+  }
+  return result.finally(() => {
+    active.delete(state);
+    state.controller.abort();
+    state.settle();
+  });
+};
+var createHostClipboardWithBackend = (options, createBackend) => {
+  const config = normalizeOptions(options);
+  const backend2 = createBackend(config);
+  const active = new Set;
+  let disposed = false;
+  let disposePromise;
+  const assertUsable = () => {
+    if (disposed)
+      throw new Error("Host clipboard service is disposed");
+  };
+  return {
+    maxWriteBytes: config.maxWriteBytes,
+    read(readOptions) {
+      try {
+        assertUsable();
+        const preferredTypes = normalizePreferredTypes(readOptions.preferredTypes);
+        const selection = normalizeSelection(readOptions.selection);
+        if (readOptions.signal?.aborted)
+          return Promise.resolve({ status: "cancelled" });
+        if (config.timeoutMs === 0)
+          return Promise.resolve({ status: "timed-out" });
+        return runTrackedOperation(active, readOptions.signal, async (signal) => {
+          const result = await backend2.read({
+            preferredTypes,
+            selection,
+            maxBytes: config.maxReadBytes,
+            timeoutMs: config.timeoutMs,
+            signal
+          });
+          if (result.status !== "read")
+            return result;
+          if (result.representation.bytes.byteLength > config.maxReadBytes)
+            return { status: "limit-exceeded" };
+          return { status: "read", representation: result.representation };
+        });
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    writeText(text, operationOptions = {}) {
+      try {
+        assertUsable();
+        validateClipboardText(text, config.maxWriteBytes);
+        const selection = normalizeSelection(operationOptions.selection);
+        if (operationOptions.signal?.aborted)
+          return Promise.resolve({ status: "cancelled" });
+        if (config.timeoutMs === 0)
+          return Promise.resolve({ status: "timed-out" });
+        return runTrackedOperation(active, operationOptions.signal, (signal) => backend2.writeText(text, { selection, timeoutMs: config.timeoutMs, signal }));
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    clear(operationOptions = {}) {
+      try {
+        assertUsable();
+        const selection = normalizeSelection(operationOptions.selection);
+        if (operationOptions.signal?.aborted)
+          return Promise.resolve({ status: "cancelled" });
+        if (config.timeoutMs === 0)
+          return Promise.resolve({ status: "timed-out" });
+        return runTrackedOperation(active, operationOptions.signal, (signal) => backend2.clear({ selection, timeoutMs: config.timeoutMs, signal }));
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    dispose() {
+      if (disposePromise)
+        return disposePromise;
+      disposed = true;
+      for (const operation of active)
+        operation.controller.abort();
+      disposePromise = (async () => {
+        await Promise.all([...active].map((operation) => operation.settled));
+        await backend2.dispose();
+      })();
+      return disposePromise;
+    }
+  };
+};
+
+// src/lib/host-clipboard.native.ts
+var SHUTDOWN_POLL_INTERVAL_MS = 1;
+var OPERATION_POLL_INTERVAL_MS = 1;
+var PROVIDER_POLL_INTERVAL_MS = 8;
+var MAX_WORK_UNITS_PER_DRAIN = 64;
+var selectionValue = (selection) => selection === "clipboard" ? 0 : 1;
+var encodeReadRequest = (preferredTypes) => {
+  const encoder = new TextEncoder;
+  const encoded = preferredTypes.map((mimeType) => encoder.encode(mimeType));
+  const size = encoded.reduce((total, mimeType) => total + 4 + mimeType.byteLength, 4);
+  const request = new Uint8Array(size);
+  const view = new DataView(request.buffer);
+  view.setUint32(0, encoded.length, true);
+  let offset = 4;
+  for (const mimeType of encoded) {
+    view.setUint32(offset, mimeType.byteLength, true);
+    offset += 4;
+    request.set(mimeType, offset);
+    offset += mimeType.byteLength;
+  }
+  return request;
+};
+var startFailure = (status) => ({
+  status: "failed",
+  error: new Error(`Native clipboard operation failed to start (${NativeClipboardStartStatus[status]})`)
+});
+
+class NativeClipboardBackend {
+  maxImagePixels;
+  maxConversionBytes;
+  library;
+  service;
+  pending = new Map;
+  pollTimer;
+  pollTimerForOperation = false;
+  providerActive = false;
+  disposed = false;
+  disposePromise;
+  constructor(maxImagePixels, maxConversionBytes, maxConcurrentOperations, maxProviderTransfers, waylandSeat) {
+    this.maxImagePixels = maxImagePixels;
+    this.maxConversionBytes = maxConversionBytes;
+    this.library = resolveRenderLib();
+    const service = this.library.clipboardServiceCreate(maxConcurrentOperations, maxProviderTransfers, waylandSeat);
+    if (!service)
+      throw new Error("Failed to create native clipboard service");
+    this.service = service;
+  }
+  read(options) {
+    const request = encodeReadRequest(options.preferredTypes);
+    const started = this.library.clipboardReadOperationStart(this.service, request, selectionValue(options.selection), options.maxBytes, this.maxImagePixels, this.maxConversionBytes, options.timeoutMs);
+    return this.track(started, options.signal, "read");
+  }
+  writeText(text, options) {
+    const started = this.library.clipboardWriteOperationStart(this.service, new TextEncoder().encode(text), selectionValue(options.selection), options.timeoutMs);
+    return this.track(started, options.signal, "write");
+  }
+  clear(options) {
+    const started = this.library.clipboardClearOperationStart(this.service, selectionValue(options.selection), options.timeoutMs);
+    return this.track(started, options.signal, "clear");
+  }
+  dispose() {
+    if (this.disposePromise)
+      return this.disposePromise;
+    this.disposed = true;
+    this.disposePromise = this.shutdown();
+    return this.disposePromise;
+  }
+  track(started, signal, kind) {
+    if (this.disposed)
+      return Promise.reject(new Error("Native clipboard backend is disposed"));
+    if (started.status !== 0 /* Ok */ || !started.operation) {
+      return Promise.resolve(startFailure(started.status));
+    }
+    return new Promise((resolve3, reject) => {
+      const operation = { handle: started.operation, kind, signal, resolve: resolve3, reject };
+      this.pending.set(operation.handle, operation);
+      signal.addEventListener("abort", () => this.requestCancel(operation), { once: true });
+      this.ensureScheduled();
+      this.drain();
+    });
+  }
+  requestCancel(operation) {
+    if (!this.pending.has(operation.handle))
+      return;
+    try {
+      this.library.clipboardOperationCancel(operation.handle);
+    } catch (error) {
+      operation.cleanupError ??= error;
+    }
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    const hasPendingOperation = this.pending.size > 0;
+    if (!hasPendingOperation && !this.providerActive) {
+      this.clearPollTimer();
+      return;
+    }
+    if (this.pollTimer !== undefined) {
+      if (hasPendingOperation && !this.pollTimerForOperation)
+        this.clearPollTimer();
+      else {
+        if (hasPendingOperation)
+          this.pollTimer.ref();
+        else
+          this.pollTimer.unref();
+        return;
+      }
+    }
+    this.pollTimerForOperation = hasPendingOperation;
+    this.pollTimer = setTimeout(() => {
+      this.pollTimer = undefined;
+      this.pollTimerForOperation = false;
+      this.drain();
+    }, hasPendingOperation ? OPERATION_POLL_INTERVAL_MS : PROVIDER_POLL_INTERVAL_MS);
+    if (!hasPendingOperation)
+      this.pollTimer.unref();
+  }
+  clearPollTimer() {
+    if (this.pollTimer === undefined)
+      return;
+    clearTimeout(this.pollTimer);
+    this.pollTimer = undefined;
+    this.pollTimerForOperation = false;
+  }
+  drain() {
+    this.providerActive = false;
+    try {
+      this.providerActive = this.library.clipboardServiceDrain(this.service) === 1;
+    } catch (error) {
+      for (const operation of this.pending.values()) {
+        operation.cleanupError ??= error;
+        try {
+          this.library.clipboardOperationCancel(operation.handle);
+        } catch {}
+      }
+    }
+    let workUnits = 0;
+    while (workUnits < MAX_WORK_UNITS_PER_DRAIN && this.pending.size > 0) {
+      const operation = this.pending.values().next().value;
+      if (!operation)
+        break;
+      workUnits += 1;
+      try {
+        if (operation.cleanupError !== undefined) {
+          try {
+            this.library.clipboardOperationCancel(operation.handle);
+          } catch {}
+          const status2 = this.library.clipboardOperationPoll(operation.handle);
+          if (status2 === 0 /* Pending */) {
+            this.rotate(operation);
+            continue;
+          }
+          this.providerActive = true;
+          const destroyed2 = this.library.clipboardOperationDestroy(operation.handle);
+          if (destroyed2 === 1 /* NotReady */) {
+            this.rotate(operation);
+            continue;
+          }
+          this.pending.delete(operation.handle);
+          operation.reject(operation.cleanupError);
+          continue;
+        }
+        if (operation.signal.aborted)
+          this.library.clipboardOperationCancel(operation.handle);
+        const status = this.library.clipboardOperationPoll(operation.handle);
+        if (status === 0 /* Pending */) {
+          this.rotate(operation);
+          continue;
+        }
+        this.providerActive = true;
+        const result = this.readResult(operation.handle, operation.kind, status);
+        const destroyed = this.library.clipboardOperationDestroy(operation.handle);
+        if (destroyed === 1 /* NotReady */) {
+          this.rotate(operation);
+          continue;
+        }
+        this.pending.delete(operation.handle);
+        operation.resolve(destroyed === 0 /* Destroyed */ ? result : { status: "failed", error: new Error("Native clipboard operation became invalid before destruction") });
+      } catch (error) {
+        operation.cleanupError ??= error;
+        try {
+          this.library.clipboardOperationCancel(operation.handle);
+        } catch {}
+        this.rotate(operation);
+      }
+    }
+    this.ensureScheduled();
+  }
+  rotate(operation) {
+    this.pending.delete(operation.handle);
+    this.pending.set(operation.handle, operation);
+  }
+  readResult(handle, kind, status) {
+    switch (status) {
+      case 1 /* Read */:
+        return kind === "read" ? this.readRepresentation(handle) : this.invalidResult(kind, status);
+      case 2 /* Empty */:
+        return kind === "read" ? { status: "empty" } : this.invalidResult(kind, status);
+      case 3 /* Written */:
+        return kind === "write" ? { status: "written" } : this.invalidResult(kind, status);
+      case 4 /* Cleared */:
+        return kind === "clear" ? { status: "cleared" } : this.invalidResult(kind, status);
+      case 5 /* Unsupported */:
+        return { status: "unsupported" };
+      case 6 /* Cancelled */:
+        return { status: "cancelled" };
+      case 7 /* TimedOut */:
+        return { status: "timed-out" };
+      case 8 /* LimitExceeded */:
+        return kind === "read" ? { status: "limit-exceeded" } : this.invalidResult(kind, status);
+      case 9 /* Failed */:
+        return { status: "failed", error: this.readError(handle) };
+      default:
+        return { status: "failed", error: new Error("Native clipboard operation returned an invalid status") };
+    }
+  }
+  invalidResult(kind, status) {
+    return {
+      status: "failed",
+      error: new Error(`Native clipboard ${kind} returned inapplicable status ${NativeClipboardOperationStatus[status]}`)
+    };
+  }
+  readRepresentation(handle) {
+    const mimeLength = this.library.clipboardOperationResultMimeLength(handle);
+    const dataLength = this.library.clipboardOperationResultDataLength(handle);
+    if (mimeLength.status !== 0 /* Ok */ || dataLength.status !== 0 /* Ok */) {
+      return { status: "failed", error: new Error("Failed to read native clipboard result lengths") };
+    }
+    const mime = new Uint8Array(mimeLength.length);
+    const bytes = new Uint8Array(dataLength.length);
+    if (this.library.clipboardOperationResultMimeCopy(handle, mime) !== 0 /* Ok */ || this.library.clipboardOperationResultDataCopy(handle, bytes) !== 0 /* Ok */) {
+      return { status: "failed", error: new Error("Failed to copy native clipboard result") };
+    }
+    return { status: "read", representation: { mimeType: new TextDecoder().decode(mime), bytes } };
+  }
+  readError(handle) {
+    const code = this.library.clipboardOperationResultErrorCode(handle);
+    const length = this.library.clipboardOperationResultDiagnosticLength(handle);
+    if (code.status !== 0 /* Ok */ || length.status !== 0 /* Ok */) {
+      return new Error("Native clipboard operation failed without a readable diagnostic");
+    }
+    const diagnostic = new Uint8Array(length.length);
+    if (this.library.clipboardOperationResultDiagnosticCopy(handle, diagnostic) !== 0 /* Ok */) {
+      return new Error("Native clipboard operation failed without a readable diagnostic");
+    }
+    return Object.assign(new Error(new TextDecoder().decode(diagnostic)), { code: code.errorCode });
+  }
+  async shutdown() {
+    this.clearPollTimer();
+    let status = this.library.clipboardServiceBeginShutdown(this.service);
+    while (status === 0 /* Pending */) {
+      await new Promise((resolve3) => setTimeout(resolve3, SHUTDOWN_POLL_INTERVAL_MS));
+      status = this.library.clipboardServicePollShutdown(this.service);
+    }
+    if (status !== 1 /* Ready */)
+      throw new Error("Native clipboard service became invalid");
+    if (this.library.clipboardServiceDestroy(this.service) !== 0 /* Destroyed */) {
+      throw new Error("Failed to destroy native clipboard service");
+    }
+  }
+}
+var createNativeHostClipboardBackend = (options) => new NativeClipboardBackend(options.maxImagePixels, options.maxConversionBytes, options.maxConcurrentOperations, options.maxProviderTransfers, options.waylandSeat);
+
 // src/lib/clipboard.ts
+var NOT_ATTEMPTED_TERMINAL = {
+  status: "not-attempted",
+  capability: "unknown"
+};
+var validateSelection = (selection) => {
+  const normalized = selection ?? "clipboard";
+  if (normalized !== "clipboard" && normalized !== "primary") {
+    throw new TypeError("selection must be clipboard or primary");
+  }
+  return normalized;
+};
+var createHostClipboard = (options = {}) => createHostClipboardWithBackend(options, createNativeHostClipboardBackend);
+var validateDestination = (destination) => {
+  if (destination !== "terminal-only" && destination !== "host-only" && destination !== "best-available" && destination !== "all-available") {
+    throw new TypeError("destination is not a supported clipboard policy");
+  }
+};
+var createClipboard = ({ host, terminal }) => {
+  const active = new Set;
+  let disposed = false;
+  let disposePromise;
+  const assertUsable = () => {
+    if (disposed)
+      throw new Error("Clipboard service is disposed");
+  };
+  const canUseRemoteHost = (options) => !terminal.remote || options.allowRemoteHost === true;
+  const composeMutation = async (options, signal, hostOperation, terminalOperation) => {
+    if (options.destination === "terminal-only") {
+      return { host: { status: "not-attempted" }, terminal: terminalOperation() };
+    }
+    if (options.destination === "host-only") {
+      const hostResult = canUseRemoteHost(options) ? await hostOperation() : { status: "not-attempted" };
+      return { host: hostResult, terminal: NOT_ATTEMPTED_TERMINAL };
+    }
+    if (options.destination === "best-available") {
+      if (terminal.remote) {
+        return { host: { status: "not-attempted" }, terminal: terminalOperation() };
+      }
+      const hostResult = await hostOperation();
+      const terminalResult2 = !signal.aborted && (hostResult.status === "unsupported" || hostResult.status === "failed") ? terminalOperation() : NOT_ATTEMPTED_TERMINAL;
+      return { host: hostResult, terminal: terminalResult2 };
+    }
+    const hostPromise = canUseRemoteHost(options) ? hostOperation() : Promise.resolve({ status: "not-attempted" });
+    const terminalResult = terminalOperation();
+    return { host: await hostPromise, terminal: terminalResult };
+  };
+  return {
+    read(options) {
+      try {
+        assertUsable();
+        return host.read(options);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    writeText(text, options) {
+      try {
+        assertUsable();
+        validateDestination(options.destination);
+        validateClipboardText(text, host.maxWriteBytes);
+        const selection = validateSelection(options.selection);
+        if (options.signal?.aborted) {
+          return Promise.resolve({ host: { status: "not-attempted" }, terminal: NOT_ATTEMPTED_TERMINAL });
+        }
+        return runTrackedOperation(active, options.signal, (signal) => {
+          const operationOptions = { selection, signal };
+          return composeMutation(options, signal, () => host.writeText(text, operationOptions), () => terminal.writeText(text, selection));
+        });
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    clear(options) {
+      try {
+        assertUsable();
+        validateDestination(options.destination);
+        const selection = validateSelection(options.selection);
+        if (options.signal?.aborted) {
+          return Promise.resolve({ host: { status: "not-attempted" }, terminal: NOT_ATTEMPTED_TERMINAL });
+        }
+        return runTrackedOperation(active, options.signal, (signal) => {
+          const operationOptions = { selection, signal };
+          return composeMutation(options, signal, () => host.clear(operationOptions), () => terminal.clear(selection));
+        });
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    },
+    dispose() {
+      if (disposePromise)
+        return disposePromise;
+      disposed = true;
+      for (const operation of active)
+        operation.controller.abort();
+      disposePromise = (async () => {
+        await Promise.all([...active].map((operation) => operation.settled));
+        await host.dispose();
+      })();
+      return disposePromise;
+    }
+  };
+};
 var ClipboardTarget;
 ((ClipboardTarget2) => {
   ClipboardTarget2[ClipboardTarget2["Clipboard"] = 0] = "Clipboard";
@@ -10535,6 +11110,33 @@ var ClipboardTarget;
   ClipboardTarget2[ClipboardTarget2["Select"] = 2] = "Select";
   ClipboardTarget2[ClipboardTarget2["Secondary"] = 3] = "Secondary";
 })(ClipboardTarget ||= {});
+var createRendererClipboardAdapter = (renderer) => {
+  const targetFor = (selection) => selection === "primary" ? 1 /* Primary */ : 0 /* Clipboard */;
+  const capability = () => renderer.capabilities?.osc52_support ?? "unknown";
+  return {
+    get remote() {
+      return renderer.capabilities?.remote ?? true;
+    },
+    writeText(text, selection) {
+      const currentCapability = capability();
+      if (currentCapability === "unsupported")
+        return { status: "not-attempted", capability: currentCapability };
+      return {
+        status: renderer.copyToClipboardOSC52(text, targetFor(selection)) ? "attempted" : "local-failure",
+        capability: currentCapability
+      };
+    },
+    clear(selection) {
+      const currentCapability = capability();
+      if (currentCapability === "unsupported")
+        return { status: "not-attempted", capability: currentCapability };
+      return {
+        status: renderer.clearClipboardOSC52(targetFor(selection)) ? "attempted" : "local-failure",
+        capability: currentCapability
+      };
+    }
+  };
+};
 
 class Clipboard {
   lib;
@@ -12761,6 +13363,55 @@ registerEnvVar({
   type: "string",
   default: ""
 });
+var NativeClipboardOperationStatus;
+((NativeClipboardOperationStatus2) => {
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["Pending"] = 0] = "Pending";
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["Read"] = 1] = "Read";
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["Empty"] = 2] = "Empty";
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["Written"] = 3] = "Written";
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["Cleared"] = 4] = "Cleared";
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["Unsupported"] = 5] = "Unsupported";
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["Cancelled"] = 6] = "Cancelled";
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["TimedOut"] = 7] = "TimedOut";
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["LimitExceeded"] = 8] = "LimitExceeded";
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["Failed"] = 9] = "Failed";
+  NativeClipboardOperationStatus2[NativeClipboardOperationStatus2["InvalidHandle"] = 10] = "InvalidHandle";
+})(NativeClipboardOperationStatus ||= {});
+var NativeClipboardStartStatus;
+((NativeClipboardStartStatus2) => {
+  NativeClipboardStartStatus2[NativeClipboardStartStatus2["Ok"] = 0] = "Ok";
+  NativeClipboardStartStatus2[NativeClipboardStartStatus2["InvalidService"] = 1] = "InvalidService";
+  NativeClipboardStartStatus2[NativeClipboardStartStatus2["ShuttingDown"] = 2] = "ShuttingDown";
+  NativeClipboardStartStatus2[NativeClipboardStartStatus2["LimitExceeded"] = 3] = "LimitExceeded";
+  NativeClipboardStartStatus2[NativeClipboardStartStatus2["InvalidArgument"] = 4] = "InvalidArgument";
+  NativeClipboardStartStatus2[NativeClipboardStartStatus2["OutOfMemory"] = 5] = "OutOfMemory";
+})(NativeClipboardStartStatus ||= {});
+var NativeClipboardCancelStatus;
+((NativeClipboardCancelStatus2) => {
+  NativeClipboardCancelStatus2[NativeClipboardCancelStatus2["Requested"] = 0] = "Requested";
+  NativeClipboardCancelStatus2[NativeClipboardCancelStatus2["AlreadyTerminal"] = 1] = "AlreadyTerminal";
+  NativeClipboardCancelStatus2[NativeClipboardCancelStatus2["InvalidHandle"] = 2] = "InvalidHandle";
+})(NativeClipboardCancelStatus ||= {});
+var NativeClipboardCopyStatus;
+((NativeClipboardCopyStatus2) => {
+  NativeClipboardCopyStatus2[NativeClipboardCopyStatus2["Ok"] = 0] = "Ok";
+  NativeClipboardCopyStatus2[NativeClipboardCopyStatus2["BufferTooSmall"] = 1] = "BufferTooSmall";
+  NativeClipboardCopyStatus2[NativeClipboardCopyStatus2["InvalidHandle"] = 2] = "InvalidHandle";
+  NativeClipboardCopyStatus2[NativeClipboardCopyStatus2["InvalidState"] = 3] = "InvalidState";
+  NativeClipboardCopyStatus2[NativeClipboardCopyStatus2["InvalidArgument"] = 4] = "InvalidArgument";
+})(NativeClipboardCopyStatus ||= {});
+var NativeClipboardDestroyStatus;
+((NativeClipboardDestroyStatus2) => {
+  NativeClipboardDestroyStatus2[NativeClipboardDestroyStatus2["Destroyed"] = 0] = "Destroyed";
+  NativeClipboardDestroyStatus2[NativeClipboardDestroyStatus2["NotReady"] = 1] = "NotReady";
+  NativeClipboardDestroyStatus2[NativeClipboardDestroyStatus2["InvalidHandle"] = 2] = "InvalidHandle";
+})(NativeClipboardDestroyStatus ||= {});
+var NativeClipboardShutdownStatus;
+((NativeClipboardShutdownStatus2) => {
+  NativeClipboardShutdownStatus2[NativeClipboardShutdownStatus2["Pending"] = 0] = "Pending";
+  NativeClipboardShutdownStatus2[NativeClipboardShutdownStatus2["Ready"] = 1] = "Ready";
+  NativeClipboardShutdownStatus2[NativeClipboardShutdownStatus2["InvalidHandle"] = 2] = "InvalidHandle";
+})(NativeClipboardShutdownStatus ||= {});
 var targetLibPath;
 var targetLibError;
 try {
@@ -13123,6 +13774,78 @@ function getOpenTUILib(libPath) {
       args: ["u32", "u8"],
       returns: "bool"
     },
+    clipboardServiceCreate: {
+      args: ["u32", "u32", "ptr", "u32"],
+      returns: "u32"
+    },
+    clipboardServiceBeginShutdown: {
+      args: ["u32"],
+      returns: "u8"
+    },
+    clipboardServicePollShutdown: {
+      args: ["u32"],
+      returns: "u8"
+    },
+    clipboardServiceDestroy: {
+      args: ["u32"],
+      returns: "u8"
+    },
+    clipboardServiceDrain: {
+      args: ["u32"],
+      returns: "u8"
+    },
+    clipboardReadOperationStart: {
+      args: ["u32", "ptr", "u32", "u8", "u32", "u32", "u32", "u32", "ptr"],
+      returns: "u8"
+    },
+    clipboardWriteOperationStart: {
+      args: ["u32", "ptr", "u32", "u8", "u32", "ptr"],
+      returns: "u8"
+    },
+    clipboardClearOperationStart: {
+      args: ["u32", "u8", "u32", "ptr"],
+      returns: "u8"
+    },
+    clipboardOperationPoll: {
+      args: ["u32"],
+      returns: "u8"
+    },
+    clipboardOperationCancel: {
+      args: ["u32"],
+      returns: "u8"
+    },
+    clipboardOperationResultMimeLength: {
+      args: ["u32", "ptr"],
+      returns: "u8"
+    },
+    clipboardOperationResultMimeCopy: {
+      args: ["u32", "ptr", "u32"],
+      returns: "u8"
+    },
+    clipboardOperationResultDataLength: {
+      args: ["u32", "ptr"],
+      returns: "u8"
+    },
+    clipboardOperationResultDataCopy: {
+      args: ["u32", "ptr", "u32"],
+      returns: "u8"
+    },
+    clipboardOperationResultErrorCode: {
+      args: ["u32", "ptr"],
+      returns: "u8"
+    },
+    clipboardOperationResultDiagnosticLength: {
+      args: ["u32", "ptr"],
+      returns: "u8"
+    },
+    clipboardOperationResultDiagnosticCopy: {
+      args: ["u32", "ptr", "u32"],
+      returns: "u8"
+    },
+    clipboardOperationDestroy: {
+      args: ["u32"],
+      returns: "u8"
+    },
     triggerNotification: {
       args: ["u32", "ptr", "u32", "ptr", "u32"],
       returns: "bool"
@@ -13836,10 +14559,16 @@ function getOpenTUILib(libPath) {
       returns: "u32"
     },
     imageInfo: { args: ["ptr", "u32", "ptr"], returns: "u32" },
+    imageRetainIccCache: { args: [], returns: "void" },
+    imageReleaseIccCache: { args: [], returns: "void" },
+    imageTestFailIccProfileCopyAllocationOnce: { args: [], returns: "void" },
     imageDecode: { args: ["ptr", "u32", "ptr"], returns: "u32" },
     imageCreateFromRgba: { args: ["ptr", "u64", "u32", "u32", "u32", "ptr"], returns: "u32" },
     imageDestroy: { args: ["u32"], returns: "void" },
+    imageRetain: { args: ["u32", "ptr"], returns: "u32" },
     imageGetInfo: { args: ["u32", "ptr"], returns: "u32" },
+    imageMaterialize: { args: ["u32"], returns: "u32" },
+    imageEnsureEncodedPng: { args: ["u32"], returns: "u32" },
     imageGetPixelsPtr: { args: ["u32"], returns: "ptr" },
     imageClone: { args: ["u32", "ptr"], returns: "u32" },
     imageCopyPixels: { args: ["u32", "ptr", "u64", "u32", "u8"], returns: "u32" },
@@ -14446,6 +15175,7 @@ var NativeMeasureTargetKind = {
 
 class FFIRenderLib {
   opentui;
+  iccCacheClient = false;
   yogaLayout = new Float32Array(6);
   yogaLayoutPtr = ptr(this.yogaLayout);
   ffiStructStorage = {
@@ -14486,6 +15216,8 @@ class FFIRenderLib {
     imageDrawOptions: allocStruct(ImageDrawOptionsStruct),
     gridDrawOptions: allocStruct(GridDrawOptionsStruct)
   };
+  disposed = false;
+  clipboardServices = new Set;
   encoder = new TextEncoder;
   decoder = new TextDecoder;
   logCallbackWrapper = null;
@@ -14512,6 +15244,8 @@ class FFIRenderLib {
   }
   constructor(libPath) {
     this.opentui = getOpenTUILib(libPath);
+    this.imageRetainIccCache();
+    this.iccCacheClient = true;
     try {
       this.setupLogging();
       this.setupEventBus();
@@ -14565,6 +15299,12 @@ class FFIRenderLib {
     this.opentui.symbols.setLogCallback(callbackPtr);
   }
   dispose() {
+    if (this.disposed)
+      return;
+    if (this.clipboardServices.size > 0) {
+      throw new Error("Cannot dispose OpenTUI native library while clipboard services are active");
+    }
+    this.disposed = true;
     try {
       if (this.eventSinkPtr) {
         this.opentui.symbols.destroyEventSink(this.eventSinkPtr);
@@ -14575,12 +15315,19 @@ class FFIRenderLib {
       this.setLogCallback(null);
     } finally {
       try {
-        this.opentui.close();
+        if (this.iccCacheClient) {
+          this.iccCacheClient = false;
+          this.imageReleaseIccCache();
+        }
       } finally {
-        this.eventCallbackWrapper = null;
-        this.logCallbackWrapper = null;
-        this.nativeSpanFeedCallbackWrapper = null;
-        this.nativeSpanFeedHandlers.clear();
+        try {
+          this.opentui.close();
+        } finally {
+          this.eventCallbackWrapper = null;
+          this.logCallbackWrapper = null;
+          this.nativeSpanFeedCallbackWrapper = null;
+          this.nativeSpanFeedHandlers.clear();
+        }
       }
     }
   }
@@ -14956,6 +15703,96 @@ class FFIRenderLib {
   clearClipboardOSC52(renderer, target) {
     return Boolean(this.opentui.symbols.clearClipboardOSC52(renderer, target));
   }
+  clipboardServiceCreate(maxConcurrentOperations, maxProviderTransfers, waylandSeat) {
+    const seat = waylandSeat === undefined ? null : this.encoder.encode(waylandSeat);
+    const handle = this.opentui.symbols.clipboardServiceCreate(toSafeFFIU32Length(maxConcurrentOperations, "clipboard operation limit"), toSafeFFIU32Length(maxProviderTransfers, "clipboard provider transfer limit"), seat, seat?.byteLength ?? 0);
+    if (handle === 0)
+      return null;
+    const service = handle;
+    this.clipboardServices.add(service);
+    return service;
+  }
+  clipboardServiceBeginShutdown(service) {
+    if (!this.clipboardServices.has(service))
+      return 2 /* InvalidHandle */;
+    return this.opentui.symbols.clipboardServiceBeginShutdown(service);
+  }
+  clipboardServicePollShutdown(service) {
+    if (!this.clipboardServices.has(service))
+      return 2 /* InvalidHandle */;
+    return this.opentui.symbols.clipboardServicePollShutdown(service);
+  }
+  clipboardServiceDestroy(service) {
+    if (!this.clipboardServices.has(service))
+      return 2 /* InvalidHandle */;
+    const status = this.opentui.symbols.clipboardServiceDestroy(service);
+    if (status === 0 /* Destroyed */)
+      this.clipboardServices.delete(service);
+    return status;
+  }
+  clipboardServiceDrain(service) {
+    if (!this.clipboardServices.has(service))
+      return 2;
+    return this.opentui.symbols.clipboardServiceDrain(service);
+  }
+  clipboardStartResult(status, output) {
+    return {
+      status,
+      operation: output[0] === 0 ? null : output[0]
+    };
+  }
+  clipboardReadOperationStart(service, request, selection2, maxBytes, maxImagePixels, maxConversionBytes, timeoutMs) {
+    const output = new Uint32Array(1);
+    const status = this.opentui.symbols.clipboardReadOperationStart(service, request, toSafeFFIU32Length(request.byteLength, "clipboard read request"), selection2, toSafeFFIU32Length(maxBytes, "clipboard read byte limit"), toSafeFFIU32Length(maxImagePixels, "clipboard image pixel limit"), toSafeFFIU32Length(maxConversionBytes, "clipboard conversion byte limit"), toSafeFFIU32Length(timeoutMs, "clipboard read timeout"), output);
+    return this.clipboardStartResult(status, output);
+  }
+  clipboardWriteOperationStart(service, textUtf8, selection2, timeoutMs) {
+    const output = new Uint32Array(1);
+    const status = this.opentui.symbols.clipboardWriteOperationStart(service, textUtf8, toSafeFFIU32Length(textUtf8.byteLength, "clipboard write text"), selection2, toSafeFFIU32Length(timeoutMs, "clipboard write timeout"), output);
+    return this.clipboardStartResult(status, output);
+  }
+  clipboardClearOperationStart(service, selection2, timeoutMs) {
+    const output = new Uint32Array(1);
+    const status = this.opentui.symbols.clipboardClearOperationStart(service, selection2, toSafeFFIU32Length(timeoutMs, "clipboard clear timeout"), output);
+    return this.clipboardStartResult(status, output);
+  }
+  clipboardOperationPoll(operation) {
+    return this.opentui.symbols.clipboardOperationPoll(operation);
+  }
+  clipboardOperationCancel(operation) {
+    return this.opentui.symbols.clipboardOperationCancel(operation);
+  }
+  clipboardResultLength(symbol, operation) {
+    const output = new Uint32Array(1);
+    const status = symbol(operation, output);
+    return { status, length: output[0] };
+  }
+  clipboardOperationResultMimeLength(operation) {
+    return this.clipboardResultLength(this.opentui.symbols.clipboardOperationResultMimeLength, operation);
+  }
+  clipboardOperationResultMimeCopy(operation, output) {
+    return this.opentui.symbols.clipboardOperationResultMimeCopy(operation, output.byteLength === 0 ? null : output, toSafeFFIU32Length(output.byteLength, "clipboard MIME output"));
+  }
+  clipboardOperationResultDataLength(operation) {
+    return this.clipboardResultLength(this.opentui.symbols.clipboardOperationResultDataLength, operation);
+  }
+  clipboardOperationResultDataCopy(operation, output) {
+    return this.opentui.symbols.clipboardOperationResultDataCopy(operation, output.byteLength === 0 ? null : output, toSafeFFIU32Length(output.byteLength, "clipboard data output"));
+  }
+  clipboardOperationResultErrorCode(operation) {
+    const output = new Uint32Array(1);
+    const status = this.opentui.symbols.clipboardOperationResultErrorCode(operation, output);
+    return { status, errorCode: output[0] };
+  }
+  clipboardOperationResultDiagnosticLength(operation) {
+    return this.clipboardResultLength(this.opentui.symbols.clipboardOperationResultDiagnosticLength, operation);
+  }
+  clipboardOperationResultDiagnosticCopy(operation, output) {
+    return this.opentui.symbols.clipboardOperationResultDiagnosticCopy(operation, output.byteLength === 0 ? null : output, toSafeFFIU32Length(output.byteLength, "clipboard diagnostic output"));
+  }
+  clipboardOperationDestroy(operation) {
+    return this.opentui.symbols.clipboardOperationDestroy(operation);
+  }
   triggerNotification(renderer, message, title) {
     const messageBytes = this.encoder.encode(message);
     const titleBytes = title === undefined ? null : this.encoder.encode(title);
@@ -16337,6 +17174,19 @@ class FFIRenderLib {
   imageDestroy(image) {
     this.opentui.symbols.imageDestroy(image);
   }
+  imageRetain(image) {
+    const output = new Uint32Array(1);
+    return this.imageHandleResult(this.opentui.symbols.imageRetain(image, output), output);
+  }
+  imageRetainIccCache() {
+    this.opentui.symbols.imageRetainIccCache();
+  }
+  imageReleaseIccCache() {
+    this.opentui.symbols.imageReleaseIccCache();
+  }
+  imageTestFailIccProfileCopyAllocationOnce() {
+    this.opentui.symbols.imageTestFailIccProfileCopyAllocationOnce();
+  }
   imageGetInfo(image) {
     const output = new ArrayBuffer(NativeImageInfoStruct.size);
     const status = this.opentui.symbols.imageGetInfo(image, output);
@@ -16346,6 +17196,12 @@ class FFIRenderLib {
     const pointer = this.opentui.symbols.imageGetPixelsPtr(image);
     return pointer === null || pointer === 0 || pointer === 0n ? null : pointer;
   }
+  imageMaterialize(image) {
+    return this.opentui.symbols.imageMaterialize(image);
+  }
+  imageEnsureEncodedPng(image) {
+    return this.opentui.symbols.imageEnsureEncodedPng(image);
+  }
   imageClone(image) {
     const output = new Uint32Array(1);
     return this.imageHandleResult(this.opentui.symbols.imageClone(image, output), output);
@@ -17389,7 +18245,7 @@ var Yoga = {
 };
 var yoga_default = Yoga;
 
-export { toArrayBuffer, singleton, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, sleep, stringWidth2 as stringWidth, resolveBundledFilePath, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, RGBA, normalizeColorValue, hexToRgb, rgbToHex, hsvToRgb, parseColor, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, terminalNamedSingleStrokeKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, getTreeSitterClient, destroyTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, normalizeTerminalPalette, buildTerminalPaletteSignature, decodePasteBytes, stripAnsiSequences, ClipboardTarget, Clipboard, detectLinks, OptimizedBuffer, TextBuffer, SpanInfoStruct, NativeAudioStreamFormat, NativeAudioStreamState, NativeAudioStreamStateNames, NativeAudioStreamCloseReason, NativeAudioStreamState2 as NativeAudioStreamState1, NativeAudioStreamCloseReason2 as NativeAudioStreamCloseReason1, NativeAudioStreamFormat2 as NativeAudioStreamFormat1, LogLevel2 as LogLevel, NativeMeasureTargetKind, setRenderLibPath, resolveRenderLib, Align, BoxSizing, Dimension, Direction, Display, Edge, Errata, ExperimentalFeature, FlexDirection, Gutter, Justify, LogLevel as LogLevel1, MeasureMode, NodeType, Overflow, PositionType, Unit, Wrap, ALIGN_AUTO, ALIGN_FLEX_START, ALIGN_CENTER, ALIGN_FLEX_END, ALIGN_STRETCH, ALIGN_BASELINE, ALIGN_SPACE_BETWEEN, ALIGN_SPACE_AROUND, ALIGN_SPACE_EVENLY, BOX_SIZING_BORDER_BOX, BOX_SIZING_CONTENT_BOX, DIMENSION_WIDTH, DIMENSION_HEIGHT, DIRECTION_INHERIT, DIRECTION_LTR, DIRECTION_RTL, DISPLAY_FLEX, DISPLAY_NONE, DISPLAY_CONTENTS, EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_START, EDGE_END, EDGE_HORIZONTAL, EDGE_VERTICAL, EDGE_ALL, ERRATA_NONE, ERRATA_STRETCH_FLEX_BASIS, ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING, ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE, ERRATA_ALL, ERRATA_CLASSIC, EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS, FLEX_DIRECTION_COLUMN, FLEX_DIRECTION_COLUMN_REVERSE, FLEX_DIRECTION_ROW, FLEX_DIRECTION_ROW_REVERSE, GUTTER_COLUMN, GUTTER_ROW, GUTTER_ALL, JUSTIFY_FLEX_START, JUSTIFY_CENTER, JUSTIFY_FLEX_END, JUSTIFY_SPACE_BETWEEN, JUSTIFY_SPACE_AROUND, JUSTIFY_SPACE_EVENLY, LOG_LEVEL_ERROR, LOG_LEVEL_WARN, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE, LOG_LEVEL_FATAL, MEASURE_MODE_UNDEFINED, MEASURE_MODE_EXACTLY, MEASURE_MODE_AT_MOST, NODE_TYPE_DEFAULT, NODE_TYPE_TEXT, OVERFLOW_VISIBLE, OVERFLOW_HIDDEN, OVERFLOW_SCROLL, POSITION_TYPE_STATIC, POSITION_TYPE_RELATIVE, POSITION_TYPE_ABSOLUTE, UNIT_UNDEFINED, UNIT_POINT, UNIT_PERCENT, UNIT_AUTO, WRAP_NO_WRAP, WRAP_WRAP, WRAP_WRAP_REVERSE, Config, Node, exports_yoga, yoga_default };
+export { toArrayBuffer, singleton, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, sleep, stringWidth2 as stringWidth, resolveBundledFilePath, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, RGBA, normalizeColorValue, hexToRgb, rgbToHex, hsvToRgb, parseColor, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, terminalNamedSingleStrokeKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, getTreeSitterClient, destroyTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, normalizeTerminalPalette, buildTerminalPaletteSignature, decodePasteBytes, stripAnsiSequences, createHostClipboard, createClipboard, ClipboardTarget, createRendererClipboardAdapter, Clipboard, detectLinks, OptimizedBuffer, TextBuffer, SpanInfoStruct, NativeAudioStreamFormat, NativeAudioStreamState, NativeAudioStreamStateNames, NativeAudioStreamCloseReason, NativeAudioStreamState2 as NativeAudioStreamState1, NativeAudioStreamCloseReason2 as NativeAudioStreamCloseReason1, NativeAudioStreamFormat2 as NativeAudioStreamFormat1, NativeClipboardOperationStatus, NativeClipboardStartStatus, NativeClipboardCancelStatus, NativeClipboardCopyStatus, NativeClipboardDestroyStatus, NativeClipboardShutdownStatus, LogLevel2 as LogLevel, NativeMeasureTargetKind, setRenderLibPath, resolveRenderLib, Align, BoxSizing, Dimension, Direction, Display, Edge, Errata, ExperimentalFeature, FlexDirection, Gutter, Justify, LogLevel as LogLevel1, MeasureMode, NodeType, Overflow, PositionType, Unit, Wrap, ALIGN_AUTO, ALIGN_FLEX_START, ALIGN_CENTER, ALIGN_FLEX_END, ALIGN_STRETCH, ALIGN_BASELINE, ALIGN_SPACE_BETWEEN, ALIGN_SPACE_AROUND, ALIGN_SPACE_EVENLY, BOX_SIZING_BORDER_BOX, BOX_SIZING_CONTENT_BOX, DIMENSION_WIDTH, DIMENSION_HEIGHT, DIRECTION_INHERIT, DIRECTION_LTR, DIRECTION_RTL, DISPLAY_FLEX, DISPLAY_NONE, DISPLAY_CONTENTS, EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_START, EDGE_END, EDGE_HORIZONTAL, EDGE_VERTICAL, EDGE_ALL, ERRATA_NONE, ERRATA_STRETCH_FLEX_BASIS, ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING, ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE, ERRATA_ALL, ERRATA_CLASSIC, EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS, FLEX_DIRECTION_COLUMN, FLEX_DIRECTION_COLUMN_REVERSE, FLEX_DIRECTION_ROW, FLEX_DIRECTION_ROW_REVERSE, GUTTER_COLUMN, GUTTER_ROW, GUTTER_ALL, JUSTIFY_FLEX_START, JUSTIFY_CENTER, JUSTIFY_FLEX_END, JUSTIFY_SPACE_BETWEEN, JUSTIFY_SPACE_AROUND, JUSTIFY_SPACE_EVENLY, LOG_LEVEL_ERROR, LOG_LEVEL_WARN, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE, LOG_LEVEL_FATAL, MEASURE_MODE_UNDEFINED, MEASURE_MODE_EXACTLY, MEASURE_MODE_AT_MOST, NODE_TYPE_DEFAULT, NODE_TYPE_TEXT, OVERFLOW_VISIBLE, OVERFLOW_HIDDEN, OVERFLOW_SCROLL, POSITION_TYPE_STATIC, POSITION_TYPE_RELATIVE, POSITION_TYPE_ABSOLUTE, UNIT_UNDEFINED, UNIT_POINT, UNIT_PERCENT, UNIT_AUTO, WRAP_NO_WRAP, WRAP_WRAP, WRAP_WRAP_REVERSE, Config, Node, exports_yoga, yoga_default };
 
-//# debugId=5F4E42714FBFA7AA64756E2164756E21
-//# sourceMappingURL=chunk-node-savhj5rp.js.map
+//# debugId=E0363CDF983A3D2164756E2164756E21
+//# sourceMappingURL=chunk-node-aj3n20gq.js.map