@opentui/core 0.0.0-20260715-e41c067a → 0.0.0-20260716-7fa53301

package/audio-stream/demuxer.d.ts

@@ -0,0 +1,19 @@
+import type { AudioStreamMetadata } from "../audio.js";
+export type AudioStreamDemuxOutput<M> = {
+    type: "audio";
+    data: Uint8Array;
+} | {
+    type: "metadata";
+    metadata: M | null;
+};
+export interface AudioStreamDemuxer<M> {
+    readonly initialMetadata: M | null;
+    push(chunk: Uint8Array): Iterable<AudioStreamDemuxOutput<M>>;
+    flush(): Iterable<AudioStreamDemuxOutput<M>>;
+    abort?(reason: unknown): void;
+}
+export type AudioStreamDemuxerFactory<M> = () => AudioStreamDemuxer<M>;
+export declare function selectAudioStreamDemuxer(options: {
+    headers: Headers;
+    metadataEncoding: string;
+}): AudioStreamDemuxer<AudioStreamMetadata> | null;

package/audio-stream/icy/demuxer.d.ts

@@ -0,0 +1,21 @@
+import type { AudioStreamMetadata } from "../../audio.js";
+import type { AudioStreamDemuxer, AudioStreamDemuxOutput } from "../demuxer.js";
+export interface IcyStreamDemuxerOptions {
+    metadataInterval: number;
+    metadataEncoding?: string;
+    headers?: Readonly<Record<string, string>>;
+}
+export declare class IcyStreamDemuxer implements AudioStreamDemuxer<AudioStreamMetadata> {
+    readonly initialMetadata: AudioStreamMetadata;
+    private audioRemaining;
+    private metadata;
+    private metadataOffset;
+    private fields;
+    private readonly interval;
+    private readonly decoder;
+    private readonly headers;
+    constructor(options: IcyStreamDemuxerOptions);
+    push(chunk: Uint8Array): IterableIterator<AudioStreamDemuxOutput<AudioStreamMetadata>>;
+    flush(): IterableIterator<AudioStreamDemuxOutput<AudioStreamMetadata>>;
+}
+export declare function createIcyStreamDemuxer(options: IcyStreamDemuxerOptions): AudioStreamDemuxer<AudioStreamMetadata>;

package/audio-stream/icy/metadata.d.ts

@@ -0,0 +1 @@
+export declare function parseIcyMetadata(bytes: Uint8Array, decoder: TextDecoder): Readonly<Record<string, string>> | null;

package/audio.d.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from "events";
-import type { AudioStats } from "./zig-structs.js";
+import { type AudioStreamDemuxer, type AudioStreamDemuxerFactory } from "./audio-stream/demuxer.js";
+import { type AudioStats } from "./zig-structs.js";
 export interface AudioSetupOptions {
     autoStart?: boolean;
     sampleRate?: number;
@@ -29,6 +30,119 @@ export interface AudioPlayOptions {
     loop?: boolean;
     groupId?: number;
 }
+export type AudioStreamBody = ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+export type AudioStreamFormat = "mp3" | "flac";
+export interface AudioStreamContentTypeContext {
+    readonly format: AudioStreamFormat;
+    readonly contentType: string | null;
+    readonly status: number;
+    readonly url: string;
+}
+export type AudioStreamContentTypePolicy = "validate" | "ignore" | ((context: AudioStreamContentTypeContext) => boolean);
+export interface AudioStreamConnectContext {
+    readonly signal: AbortSignal;
+    readonly attempt: number;
+}
+export interface AudioStreamConnection<I = unknown> {
+    readonly body: AudioStreamBody;
+    readonly info: I;
+    close?(): void | Promise<void>;
+}
+export type AudioStreamRetryPhase = "connect" | "read";
+export interface AudioStreamRetryContext {
+    readonly attempt: number;
+    readonly maxRetries: number;
+    readonly phase: AudioStreamRetryPhase;
+}
+export type AudioStreamRetryDecision = false | {
+    readonly delayMs?: number;
+};
+export interface AudioStreamConnector<I = unknown> {
+    connect(context: AudioStreamConnectContext): Promise<AudioStreamConnection<I>>;
+}
+export interface AudioStreamBufferOptions {
+    capacityMs?: number;
+    startupMs?: number;
+    resumeMs?: number;
+}
+export interface AudioStreamReconnectOptions {
+    maxRetries?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    backoffFactor?: number;
+    retryOnEnd?: boolean;
+    retry?(error: AudioStreamError, context: AudioStreamRetryContext): AudioStreamRetryDecision;
+}
+export interface AudioStreamOptions {
+    format?: AudioStreamFormat;
+    volume?: number;
+    pan?: number;
+    groupId?: number;
+    maxProbeBytes?: number;
+    buffer?: AudioStreamBufferOptions;
+    signal?: AbortSignal;
+}
+export interface AudioStreamBodyOptions<M = AudioStreamMetadata> extends AudioStreamOptions {
+    demuxer?: AudioStreamDemuxerFactory<M>;
+    contentTypePolicy?: never;
+    request?: never;
+    reconnect?: never;
+    metadataEncoding?: never;
+}
+export interface AudioStreamSourceOptions<I = unknown, M = AudioStreamMetadata> extends AudioStreamOptions {
+    demuxer?: (info: I) => AudioStreamDemuxer<M> | null;
+    reconnect?: AudioStreamReconnectOptions;
+    contentTypePolicy?: never;
+    request?: never;
+    metadataEncoding?: never;
+}
+export interface AudioStreamUrlOptions extends AudioStreamOptions {
+    request?: Omit<RequestInit, "body" | "signal">;
+    reconnect?: AudioStreamReconnectOptions;
+    metadataEncoding?: string;
+    contentTypePolicy?: AudioStreamContentTypePolicy;
+    demuxer?: never;
+}
+export type AudioStreamState = "initializing" | "buffering" | "playing" | "reconnecting" | "ended" | "errored" | "disposed";
+export interface AudioStreamStats {
+    state: AudioStreamState;
+    sampleRate: number;
+    channels: number;
+    bufferedFrames: number;
+    capacityFrames: number;
+    bufferedDurationMs: number;
+    bytesReceived: bigint;
+    framesDecoded: bigint;
+    framesPlayed: bigint;
+    underruns: number;
+    reconnectAttempts: number;
+}
+export type AudioStreamMetadataFormat = "icy";
+export interface AudioStreamMetadata {
+    readonly format: AudioStreamMetadataFormat;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly fields: Readonly<Record<string, string>>;
+}
+export type AudioStreamAction = "fetch" | "response" | "source" | "demuxer" | "create" | "write" | "end" | "restart" | "stats" | "decoder" | "destroy" | "setVolume" | "setPan" | "setGroup";
+export interface AudioStreamErrorContext {
+    action: AudioStreamAction;
+    status?: number;
+    errorCode?: number;
+    attempt?: number;
+}
+export interface AudioStreamReconnectEvent {
+    attempt: number;
+    delayMs: number;
+    maxRetries: number;
+    error: AudioStreamError;
+}
+export interface AudioStreamEvents<M = AudioStreamMetadata> {
+    metadata: [metadata: M | null];
+    reconnecting: [event: AudioStreamReconnectEvent];
+    ended: [];
+    error: [error: Error, context: AudioStreamErrorContext];
+    disposed: [];
+}
 export type AudioGroup = number;
 export type AudioVoice = number;
 export type AudioSound = number;
@@ -49,15 +163,97 @@ export interface AudioEvents {
     stopped: [];
     disposed: [];
 }
+export type AudioInitializationAction = "resolveRenderLib" | "createAudioEngine" | "start";
+export declare class AudioInitializationError extends Error {
+    readonly action: AudioInitializationAction;
+    readonly status?: number;
+    constructor(action: AudioInitializationAction, message: string, status?: number, cause?: unknown);
+}
+export declare class AudioStreamError extends Error {
+    readonly context: AudioStreamErrorContext;
+    constructor(message: string, context: AudioStreamErrorContext, cause?: unknown);
+}
+export declare class AudioStream<M = AudioStreamMetadata> extends EventEmitter<AudioStreamEvents<M>> {
+    readonly closed: Promise<void>;
+    readonly format: AudioStreamFormat;
+    private readonly lib;
+    private readonly engine;
+    private readonly connector;
+    private readonly demuxerFactory?;
+    private readonly readAction;
+    private readonly options;
+    private readonly removeFromOwner;
+    private readonly lifecycleController;
+    private nativeStreamId;
+    private nativeStats;
+    private activeAttempt;
+    private pendingCleanup;
+    private reconnectAttempts;
+    private consecutiveReconnectAttempts;
+    private disposed;
+    private exposed;
+    private terminalError;
+    private metadata;
+    private pendingMetadataEvent;
+    private metadataEventScheduled;
+    private terminalEventScheduled;
+    private setupResolve;
+    private setupReject;
+    private closedResolve;
+    private readonly setupPromise;
+    private readonly overallAbortListener;
+    private constructor();
+    get state(): AudioStreamState;
+    private open;
+    getStats(): AudioStreamStats;
+    getMetadata(): M | null;
+    setVolume(volume: number): boolean;
+    setPan(pan: number): boolean;
+    setGroup(groupId: number): boolean;
+    private control;
+    dispose(): void;
+    private runLifecycle;
+    private createNativeStream;
+    private consumeSource;
+    private pumpSource;
+    private processDemuxOutput;
+    private writeStreamChunk;
+    private resolveConnection;
+    private beginResourceAcquisition;
+    private cleanupAttempt;
+    private performAttemptCleanup;
+    private runBoundedAttemptCleanup;
+    private retry;
+    private awaitReady;
+    private observeReady;
+    private awaitEnded;
+    private pollNativeSnapshot;
+    private snapshotError;
+    private finish;
+    private publishMetadata;
+    private emitMetadata;
+    private emitAsync;
+    private emitTerminal;
+    private isAttemptActive;
+    private stopSource;
+    private closeNativeStream;
+    private readNativeStats;
+    private toPublicStats;
+    private removeOwner;
+}
 export declare class Audio extends EventEmitter<AudioEvents> {
     static create(options?: AudioSetupOptions): Audio;
+    readonly sampleRate: number;
     private readonly lib;
     private readonly defaultStartOptions;
     private engine;
     private readonly groups;
+    private readonly streams;
     private playbackStarted;
     private mixerStarted;
+    private disposing;
     private constructor();
+    private throwAfterInitializationCleanup;
     private emitError;
     start(options?: AudioStartOptions): boolean;
     startMixer(): boolean;
@@ -69,6 +265,10 @@ export declare class Audio extends EventEmitter<AudioEvents> {
     unloadSound(sound: AudioSound): boolean;
     group(name: string): AudioGroup | null;
     play(sound: AudioSound, options?: AudioPlayOptions): AudioVoice | null;
+    playStream<M = AudioStreamMetadata>(source: AudioStreamBody, options?: AudioStreamBodyOptions<M>): Promise<AudioStream<M>>;
+    playStreamUrl(source: string | URL, options?: AudioStreamUrlOptions): Promise<AudioStream<AudioStreamMetadata>>;
+    playStreamSource<I, M = AudioStreamMetadata>(connector: AudioStreamConnector<I>, options?: AudioStreamSourceOptions<I, M>): Promise<AudioStream<M>>;
+    private openStream;
     stopVoice(voice: AudioVoice): boolean;
     setVoiceGroup(voice: AudioVoice, group: AudioGroup): boolean;
     setGroupVolume(group: AudioGroup, volume: number): boolean;

package/{index-y6278spm.js → index-fbg5wkm5.js}

@@ -202,6 +202,17 @@ var POINTER_NEGATIVE = "Pointer must be non-negative";
 var POINTER_OFFSET_NEGATIVE = "Pointer offset must be non-negative";
 var POINTER_OFFSET_UNSAFE = "Pointer offset must be a safe integer";
 var POINTER_UNSAFE = "Pointer exceeds safe integer range";
+var arrayBufferByteLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength")?.get;
+function isArrayBuffer(value) {
+  if (value === null || typeof value !== "object" || arrayBufferByteLength == null)
+    return false;
+  try {
+    arrayBufferByteLength.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function unavailable(cause) {
   throw new Error(FFI_UNAVAILABLE, { cause });
 }
@@ -429,7 +440,7 @@ function toNodePointerArgument(value) {
     return toBigIntPointer(value);
   }
   if (ArrayBuffer.isView(value)) {
-    if (!(value.buffer instanceof ArrayBuffer)) {
+    if (!isArrayBuffer(value.buffer)) {
       throw new TypeError(NODE_PTR_VALUE);
     }
     if (value.byteLength === 0) {
@@ -437,7 +448,7 @@ function toNodePointerArgument(value) {
     }
     return value;
   }
-  if (value instanceof ArrayBuffer) {
+  if (isArrayBuffer(value)) {
     if (value.byteLength === 0) {
       return 0n;
     }
@@ -447,12 +458,12 @@ function toNodePointerArgument(value) {
 }
 function toNodeSourcePointer(nodeFfi, value) {
   if (ArrayBuffer.isView(value)) {
-    if (!(value.buffer instanceof ArrayBuffer)) {
+    if (!isArrayBuffer(value.buffer)) {
       throw new TypeError(NODE_PTR_VALUE);
     }
     return nodeFfi.getRawPointer(value.buffer) + BigInt(value.byteOffset);
   }
-  if (value instanceof ArrayBuffer) {
+  if (isArrayBuffer(value)) {
     return nodeFfi.getRawPointer(value);
   }
   throw new TypeError(NODE_PTR_VALUE);
@@ -12412,6 +12423,33 @@ var ReserveInfoStruct = defineStruct([
     len: value.len
   })
 });
+var NativeAudioStreamFormat = {
+  Mp3: 1,
+  Flac: 2
+};
+var NativeAudioStreamState = {
+  Initializing: 0,
+  Buffering: 1,
+  Playing: 2,
+  Ended: 3,
+  Failed: 4,
+  Cancelled: 5,
+  Reconnecting: 6
+};
+var NativeAudioStreamStateNames = [
+  "initializing",
+  "buffering",
+  "playing",
+  "ended",
+  "errored",
+  "disposed",
+  "reconnecting"
+];
+var NativeAudioStreamCloseReason = {
+  PreserveNativeTerminal: 0,
+  TransportError: 1,
+  Disposed: 2
+};
 var AudioCreateOptionsStruct = defineStruct([
   ["sampleRate", "u32", { default: 48000 }],
   ["playbackChannels", "u32", { default: 2 }]
@@ -12439,6 +12477,29 @@ var AudioVoiceOptionsStruct = defineStruct([
   ["loop", "bool_u8", { default: false }],
   ["groupId", "u32", { default: 0 }]
 ]);
+var AudioStreamCreateOptionsStruct = defineStruct([
+  ["capacityMs", "u32"],
+  ["startupMs", "u32"],
+  ["resumeMs", "u32"],
+  ["volume", "f32"],
+  ["pan", "f32"],
+  ["groupId", "u32"],
+  ["maxProbeBytes", "u32"],
+  ["format", "u32"]
+]);
+var AudioStreamStatsStruct = defineStruct([
+  ["bytesReceived", "u64"],
+  ["framesDecoded", "u64"],
+  ["framesPlayed", "u64"],
+  ["state", "u32"],
+  ["sampleRate", "u32"],
+  ["channels", "u32"],
+  ["bufferedFrames", "u32"],
+  ["capacityFrames", "u32"],
+  ["underruns", "u32"],
+  ["errorCode", "i32"],
+  ["readyGeneration", "u32"]
+]);
 var AudioStatsStruct = defineStruct([
   ["soundsLoaded", "u32"],
   ["voicesActive", "u32"],
@@ -12449,6 +12510,9 @@ var AudioStatsStruct = defineStruct([
 ]);
 
 // src/zig.ts
+var NativeAudioStreamState2 = NativeAudioStreamState;
+var NativeAudioStreamCloseReason2 = NativeAudioStreamCloseReason;
+var NativeAudioStreamFormat2 = NativeAudioStreamFormat;
 registerEnvVar({
   name: "OPENTUI_LIBC",
   description: "Select Linux native libc package. Supported values: glibc, musl.",
@@ -12611,6 +12675,9 @@ function toSafeFFIU32Length(value, label) {
   }
   return value;
 }
+function isFFIU32(value) {
+  return Number.isInteger(value) && value >= 0 && value <= MAX_FFI_U32;
+}
 function ptrOrNull(value) {
   return value.byteLength === 0 ? null : ptr(value);
 }
@@ -13931,6 +13998,42 @@ function getOpenTUILib(libPath) {
       args: ["u32"],
       returns: "i32"
     },
+    audioCreateStream: {
+      args: ["u32", "ptr", "ptr"],
+      returns: "i32"
+    },
+    audioWriteStream: {
+      args: ["u32", "u32", "ptr", "u32"],
+      returns: "i32"
+    },
+    audioEndStream: {
+      args: ["u32", "u32"],
+      returns: "i32"
+    },
+    audioRestartStream: {
+      args: ["u32", "u32"],
+      returns: "i32"
+    },
+    audioSetStreamVolume: {
+      args: ["u32", "u32", "f32"],
+      returns: "i32"
+    },
+    audioSetStreamPan: {
+      args: ["u32", "u32", "f32"],
+      returns: "i32"
+    },
+    audioSetStreamGroup: {
+      args: ["u32", "u32", "u32"],
+      returns: "i32"
+    },
+    audioGetStreamStats: {
+      args: ["u32", "u32", "ptr"],
+      returns: "i32"
+    },
+    audioCloseStream: {
+      args: ["u32", "u32", "u32", "ptr"],
+      returns: "i32"
+    },
     audioLoad: {
       args: ["u32", "ptr", "u32", "ptr"],
       returns: "i32"
@@ -15783,7 +15886,12 @@ class FFIRenderLib {
     this.opentui.symbols.audioClearPlaybackDeviceSelection(engine);
   }
   audioStart(engine, options) {
-    const optionsBuffer = options == null ? null : AudioStartOptionsStruct.pack(options);
+    let optionsBuffer;
+    try {
+      optionsBuffer = options == null ? null : AudioStartOptionsStruct.pack(options);
+    } catch {
+      return -1;
+    }
     return this.opentui.symbols.audioStart(engine, optionsBuffer ? ptr(optionsBuffer) : null);
   }
   audioStartMixer(engine) {
@@ -15792,6 +15900,52 @@ class FFIRenderLib {
   audioStop(engine) {
     return this.opentui.symbols.audioStop(engine);
   }
+  audioCreateStream(engine, options) {
+    if (!isFFIU32(options.groupId) || options.format !== NativeAudioStreamFormat2.Mp3 && options.format !== NativeAudioStreamFormat2.Flac) {
+      return { status: -1, streamId: null };
+    }
+    const optionsBuffer = AudioStreamCreateOptionsStruct.pack(options);
+    const outBuffer = new ArrayBuffer(4);
+    const status = this.opentui.symbols.audioCreateStream(engine, optionsBuffer, outBuffer);
+    if (status !== 0)
+      return { status, streamId: null };
+    return { status, streamId: new Uint32Array(outBuffer)[0] ?? null };
+  }
+  audioWriteStream(engine, streamId, data) {
+    const dataLength = toSafeFFIU32Length(data.byteLength, "Audio stream data length");
+    return this.opentui.symbols.audioWriteStream(engine, streamId, dataLength === 0 ? null : data, dataLength);
+  }
+  audioEndStream(engine, streamId) {
+    return this.opentui.symbols.audioEndStream(engine, streamId);
+  }
+  audioRestartStream(engine, streamId) {
+    return this.opentui.symbols.audioRestartStream(engine, streamId);
+  }
+  audioSetStreamVolume(engine, streamId, volume) {
+    return this.opentui.symbols.audioSetStreamVolume(engine, streamId, volume);
+  }
+  audioSetStreamPan(engine, streamId, pan) {
+    return this.opentui.symbols.audioSetStreamPan(engine, streamId, pan);
+  }
+  audioSetStreamGroup(engine, streamId, groupId) {
+    if (!isFFIU32(groupId))
+      return -1;
+    return this.opentui.symbols.audioSetStreamGroup(engine, streamId, groupId);
+  }
+  audioGetStreamStats(engine, streamId) {
+    const outBuffer = new ArrayBuffer(AudioStreamStatsStruct.size);
+    const status = this.opentui.symbols.audioGetStreamStats(engine, streamId, outBuffer);
+    if (status !== 0)
+      return null;
+    return AudioStreamStatsStruct.unpack(outBuffer);
+  }
+  audioCloseStream(engine, streamId, reason) {
+    const outBuffer = new ArrayBuffer(AudioStreamStatsStruct.size);
+    const status = this.opentui.symbols.audioCloseStream(engine, streamId, reason, outBuffer);
+    if (status !== 0)
+      return { status, stats: null };
+    return { status, stats: AudioStreamStatsStruct.unpack(outBuffer) };
+  }
   audioLoad(engine, data) {
     const outBuffer = new ArrayBuffer(4);
     const dataLength = toSafeFFIU32Length(data.byteLength, "Audio data length");
@@ -15806,6 +15960,8 @@ class FFIRenderLib {
     return this.opentui.symbols.audioUnload(engine, soundId);
   }
   audioPlay(engine, soundId, options) {
+    if (options?.groupId !== undefined && !isFFIU32(options.groupId))
+      return { status: -1, voiceId: null };
     const outBuffer = new ArrayBuffer(4);
     const optionsBuffer = options ? AudioVoiceOptionsStruct.pack(options) : null;
     const status = this.opentui.symbols.audioPlay(engine, soundId, optionsBuffer ? ptr(optionsBuffer) : null, ptr(outBuffer));
@@ -15819,6 +15975,8 @@ class FFIRenderLib {
     return this.opentui.symbols.audioStopVoice(engine, voiceId);
   }
   audioSetVoiceGroup(engine, voiceId, groupId) {
+    if (!isFFIU32(groupId))
+      return -1;
     return this.opentui.symbols.audioSetVoiceGroup(engine, voiceId, groupId);
   }
   audioCreateGroup(engine, name) {
@@ -16974,7 +17132,7 @@ var Yoga = {
 };
 var yoga_default = Yoga;
 
-export { toArrayBuffer, sleep, stringWidth2 as stringWidth, 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, singleton, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, 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, 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 };
+export { toArrayBuffer, sleep, stringWidth2 as stringWidth, 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, singleton, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, 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=4FBC596E6DB119E964756E2164756E21
-//# sourceMappingURL=index-y6278spm.js.map
+//# debugId=810D7F8C9A56846964756E2164756E21
+//# sourceMappingURL=index-fbg5wkm5.js.map