@visulima/tui 1.0.0-alpha.9 → 1.0.1

package/dist/ink/hooks/use-input.js

@@ -0,0 +1,2 @@
+import{createRequire as $}from"node:module";import{useRef as L,useEffectEvent as _,useEffect as g}from"react";import{IMECompositionBuffer as S,isIMEInput as q}from"../../packem_shared/IMECompositionBuffer-VhC9HRCv.js";import{kittyModifiers as p}from"../../packem_shared/kittyFlags-g8ALyoCU.js";import{j as w}from"../../packem_shared/reconciler-CFyBVf7l.js";import{useStdinContext as I}from"./use-stdin.js";const C=$(import.meta.url),m=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,P=e=>{if(typeof m<"u"&&m.versions&&m.versions.node){const[a,n]=m.versions.node.split(".").map(Number);if(a>22||a===22&&n>=3||a===20&&n>=16)return m.getBuiltinModule(e)}return C(e)},{Buffer:E}=P("node:buffer"),j=/^\u001B([a-z0-9])$/i,N=/^\u001B+([ON[]|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/,y={"[1~":"home","[2$":"insert","[2^":"insert","[2~":"insert","[3$":"delete","[3^":"delete","[3~":"delete","[4~":"end","[5$":"pageup","[5^":"pageup","[5~":"pageup","[6$":"pagedown","[6^":"pagedown","[6~":"pagedown","[7$":"home","[7^":"home","[7~":"home","[8$":"end","[8^":"end","[8~":"end","[11~":"f1","[12~":"f2","[13~":"f3","[14~":"f4","[15~":"f5","[17~":"f6","[18~":"f7","[19~":"f8","[20~":"f9","[21~":"f10","[23~":"f11","[24~":"f12","[[5~":"pageup","[[6~":"pagedown","[[A":"f1","[[B":"f2","[[C":"f3","[[D":"f4","[[E":"f5","[A":"up","[a":"up","[B":"down","[b":"down","[C":"right","[c":"right","[D":"left","[d":"left","[E":"clear","[e":"clear","[F":"end","[H":"home","[P":"f1","[Q":"f2","[R":"f3","[S":"f4","[Z":"tab",OA:"up",Oa:"up",OB:"down",Ob:"down",OC:"right",Oc:"right",OD:"left",Od:"left",OE:"clear",Oe:"clear",OF:"end",OH:"home",OP:"f1",OQ:"f2",OR:"f3",OS:"f4"},M=[...Object.values(y),"backspace"],T=e=>["[2$","[3$","[5$","[6$","[7$","[8$","[a","[b","[c","[d","[e","[Z"].includes(e),K=e=>["[2^","[3^","[5^","[6^","[7^","[8^","Oa","Ob","Oc","Od","Oe"].includes(e),B=/^\u001B\[(\d+)(?:;(\d+)(?::(\d+))?(?:;([\d:]+))?)?u$/,R=/^\u001B\[(\d+);(\d+):(\d+)([A-Z~])$/i,Z={A:"up",B:"down",C:"right",D:"left",E:"clear",F:"end",H:"home",P:"f1",Q:"f2",R:"f3",S:"f4"},D={2:"insert",3:"delete",5:"pageup",6:"pagedown",7:"home",8:"end",11:"f1",12:"f2",13:"f3",14:"f4",15:"f5",17:"f6",18:"f7",19:"f8",20:"f9",21:"f10",23:"f11",24:"f12"},v={8:"backspace",9:"tab",27:"escape",127:"backspace",57358:"capslock",57359:"scrolllock",57360:"numlock",57361:"printscreen",57362:"pause",57363:"menu",57376:"f13",57377:"f14",57378:"f15",57379:"f16",57380:"f17",57381:"f18",57382:"f19",57383:"f20",57384:"f21",57385:"f22",57386:"f23",57387:"f24",57388:"f25",57389:"f26",57390:"f27",57391:"f28",57392:"f29",57393:"f30",57394:"f31",57395:"f32",57396:"f33",57397:"f34",57398:"f35",57399:"kp0",57400:"kp1",57401:"kp2",57402:"kp3",57403:"kp4",57404:"kp5",57405:"kp6",57406:"kp7",57407:"kp8",57408:"kp9",57409:"kpdecimal",57410:"kpdivide",57411:"kpmultiply",57412:"kpsubtract",57413:"kpadd",57414:"kpenter",57415:"kpequal",57416:"kpseparator",57417:"kpleft",57418:"kpright",57419:"kpup",57420:"kpdown",57421:"kppageup",57422:"kppagedown",57423:"kphome",57424:"kpend",57425:"kpinsert",57426:"kpdelete",57427:"kpbegin",57428:"mediaplay",57429:"mediapause",57430:"mediaplaypause",57431:"mediareverse",57432:"mediastop",57433:"mediafastforward",57434:"mediarewind",57435:"mediatracknext",57436:"mediatrackprevious",57437:"mediarecord",57438:"lowervolume",57439:"raisevolume",57440:"mutevolume",57441:"leftshift",57442:"leftcontrol",57443:"leftalt",57444:"leftsuper",57445:"lefthyper",57446:"leftmeta",57447:"rightshift",57448:"rightcontrol",57449:"rightalt",57450:"rightsuper",57451:"righthyper",57452:"rightmeta",57453:"isoLevel3Shift",57454:"isoLevel5Shift"},x=e=>e>=0&&e<=1114111&&!(e>=55296&&e<=57343),b=e=>x(e)?String.fromCodePoint(e):"?";function A(e){return e===3?"release":e===2?"repeat":"press"}function O(e){return{capsLock:!!(e&p.capsLock),ctrl:!!(e&p.ctrl),hyper:!!(e&p.hyper),meta:!!(e&p.meta),numLock:!!(e&p.numLock),option:!!(e&p.alt),shift:!!(e&p.shift),super:!!(e&p.super)}}const F=e=>{const a=B.exec(e);if(!a)return null;const n=Number.parseInt(a[1],10),c=a[2]?Math.max(0,Number.parseInt(a[2],10)-1):0,t=a[3]?Number.parseInt(a[3],10):1,l=a[4];if(!x(n))return null;let s;l&&(s=l.split(":").map(d=>b(Number.parseInt(d,10))).join(""));let o,i;return n===32?(o="space",i=!0):n===13?(o="return",i=!0):v[n]?(o=v[n],i=!1):n>=1&&n<=26?(o=String.fromCodePoint(n+96),i=!1):(o=b(n).toLowerCase(),i=!0),i&&!s&&(s=b(n)),{name:o,...O(c),eventType:A(t),isKittyProtocol:!0,isPrintable:i,raw:e,sequence:e,text:s}},U=e=>{const a=R.exec(e);if(!a)return null;const n=Number.parseInt(a[1],10),c=Math.max(0,Number.parseInt(a[2],10)-1),t=Number.parseInt(a[3],10),l=a[4],s=l==="~"?D[n]:Z[l];return s?{name:s,...O(c),eventType:A(t),isKittyProtocol:!0,isPrintable:!1,raw:e,sequence:e}:null},z=(e="")=>{let a;E.isBuffer(e)?e[0]>127&&e[1]===void 0?(e[0]-=128,e=`\x1B${String(e)}`):e=String(e):e!==void 0&&typeof e!="string"?e=String(e):e||(e="");const n=F(e);if(n)return n;const c=U(e);if(c)return c;if(B.test(e))return{ctrl:!1,isKittyProtocol:!0,isPrintable:!1,meta:!1,name:"",option:!1,raw:e,sequence:e,shift:!1};const t={ctrl:!1,meta:!1,name:"",option:!1,raw:e,sequence:e,shift:!1};switch(t.sequence=t.sequence||e||t.name,e){case"\r":case"\x1B\r":{t.raw=void 0,t.name="return",t.option=e.length===2;break}case`
+`:{t.name="enter";break}case"	":{t.name="tab";break}case" ":case"\x1B ":{t.name="space",t.meta=e.length===2;break}case"\b":case"\x1B\b":{t.name="backspace",t.meta=e.charAt(0)==="\x1B";break}case"\x1B":case"\x1B\x1B":{t.name="escape",t.meta=e.length===2;break}case"\x1B":case"":{t.name="backspace",t.meta=e.charAt(0)==="\x1B";break}default:if(e.length===1&&e<="")t.name=String.fromCharCode(e.charCodeAt(0)+97-1),t.ctrl=!0;else if(e.length===1&&e>="0"&&e<="9")t.name="number";else if(e.length===1&&e>="a"&&e<="z")t.name=e;else if(e.length===1&&e>="A"&&e<="Z")t.name=e.toLowerCase(),t.shift=!0;else if(a=j.exec(e))t.meta=!0,t.shift=/^[A-Z]$/.test(a[1]);else if(a=N.exec(e)){const l=[...e];l[0]==="\x1B"&&l[1]==="\x1B"&&(t.option=!0);const s=[a[1],a[2],a[4],a[6]].filter(Boolean).join(""),o=(a[3]||a[5]||1)-1;t.ctrl=!!(o&4),t.meta=!!(o&10),t.shift=!!(o&1),t.code=s,t.name=y[s]??"",t.shift=T(s)||t.shift,t.ctrl=K(s)||t.ctrl}}return t},X=(e,a={})=>{const{internal_eventEmitter:n,internal_exitOnCtrlC:c,setRawMode:t,stdin:l}=I(),s=a.imeEnabled??!0,o=a.imeTimeout??50,i=L(void 0),d=_(e);g(()=>{if(s)return i.current=new S({onFlush:h=>{const u={backspace:!1,capsLock:!1,ctrl:!1,delete:!1,downArrow:!1,end:!1,escape:!1,home:!1,hyper:!1,leftArrow:!1,meta:!1,numLock:!1,pageDown:!1,pageUp:!1,return:!1,rightArrow:!1,shift:!1,super:!1,tab:!1,upArrow:!1};w.discreteUpdates(()=>{d(h,u)})},timeout:o}),()=>{i.current?.destroy(),i.current=void 0}},[s,o]),g(()=>{if(a.isActive!==!1)return t(!0),()=>{t(!1)}},[a.isActive,t]),g(()=>{if(a.isActive===!1)return;const h=u=>{if(s&&q(u)){i.current?.add(u);return}i.current?.flush();const r=z(u),k={backspace:r.name==="backspace",capsLock:r.capsLock??!1,ctrl:r.ctrl,delete:r.name==="delete",downArrow:r.name==="down",end:r.name==="end",escape:r.name==="escape",eventType:r.eventType,home:r.name==="home",hyper:r.hyper??!1,leftArrow:r.name==="left",meta:r.meta||r.option,numLock:r.numLock??!1,pageDown:r.name==="pagedown",pageUp:r.name==="pageup",return:r.name==="return",rightArrow:r.name==="right",shift:r.shift,super:r.super??!1,tab:r.name==="tab",upArrow:r.name==="up"};let f;r.isKittyProtocol?r.isPrintable?f=r.text??r.name:r.ctrl&&r.name.length===1?f=r.name:f="":r.ctrl?f=r.name:f=r.sequence,!r.isKittyProtocol&&M.includes(r.name)&&(f=""),f.startsWith("\x1B")&&(f=f.slice(1)),f.length===1&&typeof f[0]=="string"&&/[A-Z]/.test(f[0])&&(k.shift=!0),!(f==="c"&&k.ctrl&&c)&&(!r.name&&f===""||w.discreteUpdates(()=>{d(f,k)}))};return n.on("input",h),()=>{n.removeListener("input",h)}},[a.isActive,l,c,s])};export{X as default,X as useInput};

package/dist/ink/hooks/use-interval.d.ts

@@ -0,0 +1,25 @@
+type UseIntervalOptions = {
+  /**
+  * When false, the timer is paused. Flipping back to true restarts it.
+  * @default true
+  */
+  readonly isActive?: boolean;
+};
+type UseIntervalResult = {
+  /**
+  * Cancel the currently-running timer. The hook effect will reschedule on
+  * the next re-render if `isActive` remains true.
+  */
+  readonly clear: () => void;
+};
+/**
+* A React hook that invokes `callback` every `interval` ms. The callback
+* reference is captured in a ref so it always sees the latest closure; only
+* `interval` and `isActive` cause the timer to be rebuilt.
+* @param callback Invoked on every tick. Latest closure is captured in a ref.
+* @param interval Tick period in milliseconds. Invalid values pause the timer.
+* @param options Optional `isActive` flag to pause without unmounting.
+* @returns A stable object with a `clear()` method to cancel on demand.
+*/
+declare const useInterval: (callback: () => void, interval: number, options?: UseIntervalOptions) => UseIntervalResult;
+export { UseIntervalOptions, UseIntervalResult, useInterval as default, useInterval };

package/dist/ink/hooks/use-interval.js

@@ -0,0 +1 @@
+import{useRef as s,useLayoutEffect as i,useEffect as o,useCallback as l}from"react";const f=(t,r,a)=>{const{isActive:u=!0}=a??{},n=s(t),e=s(void 0);return i(()=>{n.current=t},[t]),o(()=>{if(!u||r<=0||!Number.isFinite(r))return;const c=setInterval(()=>{n.current()},r);return e.current=c,()=>{clearInterval(c),e.current=void 0}},[r,u]),{clear:l(()=>{e.current!==void 0&&(clearInterval(e.current),e.current=void 0)},[])}};export{f as default,f as useInterval};

package/dist/ink/hooks/use-is-screen-reader-enabled.d.ts

@@ -0,0 +1,6 @@
+/**
+* A React hook that returns whether a screen reader is enabled.
+* This is useful when you want to render different output for screen readers.
+*/
+declare const useIsScreenReaderEnabled: () => boolean;
+export { useIsScreenReaderEnabled as default, useIsScreenReaderEnabled };

package/dist/ink/hooks/use-is-screen-reader-enabled.js

@@ -0,0 +1 @@
+import{useContext as t}from"react";import{a as r}from"../../packem_shared/accessibility-context-DDyHTwmA.js";const n=()=>{const{isScreenReaderEnabled:e}=t(r);return e};export{n as default,n as useIsScreenReaderEnabled};

package/dist/ink/hooks/use-key-bindings.d.ts

@@ -0,0 +1,59 @@
+/**
+* A single key binding definition.
+*/
+type KeyBinding = {
+  /** Human-readable description shown in Help. */
+  readonly description: string;
+  /**
+  * Whether this binding is active.
+  * @default true
+  */
+  readonly enabled?: boolean;
+  /** Optional group name for organizing in the Help component's full mode. */
+  readonly group?: string;
+  /**
+  * Key(s) that trigger this binding.
+  *
+  * A string can be:
+  * - A single character: `"q"`, `"a"`, `" "` (space)
+  * - A `Key` boolean field name: `"return"`, `"escape"`, `"upArrow"`, `"leftArrow"`, etc.
+  * - A modifier combo: `"ctrl+c"`, `"meta+s"` (modifier + character)
+  *
+  * Provide an array to match multiple keys for the same action.
+  */
+  readonly key: string | ReadonlyArray<string>;
+};
+/**
+* A binding paired with its handler function.
+*/
+type KeyBindingHandler = {
+  readonly binding: KeyBinding;
+  readonly handler: () => void;
+};
+type UseKeyBindingsOptions = {
+  /**
+  * Whether keyboard input is captured.
+  * @default true
+  */
+  readonly isActive?: boolean;
+};
+type UseKeyBindingsResult = {
+  /** The enabled bindings, suitable for passing to the Help component. */
+  readonly bindings: ReadonlyArray<KeyBinding>;
+};
+/**
+* Declarative keybinding hook. Registers multiple key bindings with handlers
+* and returns the enabled bindings for display in a Help component.
+*
+* ```tsx
+* const { bindings } = useKeyBindings([
+*   { binding: { key: "q", description: "Quit" }, handler: () => exit() },
+*   { binding: { key: ["upArrow", "k"], description: "Move up" }, handler: () => moveUp() },
+*   { binding: { key: "ctrl+s", description: "Save" }, handler: () => save() },
+* ]);
+*
+* &lt;Help bindings={bindings} />
+* ```
+*/
+declare function useKeyBindings(handlers: ReadonlyArray<KeyBindingHandler>, options?: UseKeyBindingsOptions): UseKeyBindingsResult;
+export { KeyBinding, KeyBindingHandler, useKeyBindings as default, useKeyBindings };

package/dist/ink/hooks/use-key-bindings.js

@@ -0,0 +1 @@
+import{useRef as l,useCallback as d,useMemo as p}from"react";import b from"./use-input.js";const a=new Set(["backspace","delete","downArrow","end","escape","home","leftArrow","pageDown","pageUp","return","rightArrow","tab","upArrow"]),g=new Set(["ctrl","hyper","meta","shift","super"]);function m(e,o,t){const r=e.indexOf("+");if(r!==-1){const n=e.slice(0,r),s=e.slice(r+1);return!g.has(n)||!t[n]?!1:a.has(s)?t[s]===!0:o===s}return a.has(e)?t[e]===!0:o===e}function y(e,o){const{isActive:t=!0}=o??{},r=l(e);return r.current=e,b(d((n,s)=>{for(const{binding:i,handler:c}of r.current){if(i.enabled===!1)continue;const f=typeof i.key=="string"?[i.key]:i.key;for(const u of f)if(m(u,n,s)){c();return}}},[]),{isActive:t}),{bindings:p(()=>e.filter(n=>n.binding.enabled!==!1).map(n=>n.binding),[e])}}export{y as default,y as useKeyBindings};

package/dist/ink/hooks/use-key-chord.d.ts

@@ -0,0 +1,25 @@
+type KeyChordStep = string;
+type UseKeyChordOptions = {
+  /**
+  * Disable the chord while keeping the component rendered.
+  * @default true
+  */
+  readonly isActive?: boolean;
+  /**
+  * Milliseconds of silence after which the partial chord resets.
+  * @default 1000
+  */
+  readonly resetAfter?: number;
+};
+/**
+* Invoke `callback` when the user types the given sequence of keys in order
+* (like Vim's `g d` or Emacs's `C-x C-s`). The chord resets automatically
+* after `resetAfter` ms of silence.
+* @param sequence Ordered list of chord steps. Each step is compared against
+* a canonical key token (e.g. `"g"`, `"space"`, `"ctrl+s"`).
+* @param callback Invoked exactly once per successful chord match. Latest
+* reference is captured in a ref.
+* @param options Optional `isActive` flag and `resetAfter` silence timeout.
+*/
+declare const useKeyChord: (sequence: ReadonlyArray<KeyChordStep>, callback: () => void, options?: UseKeyChordOptions) => void;
+export { KeyChordStep, UseKeyChordOptions, useKeyChord as default, useKeyChord };

package/dist/ink/hooks/use-key-chord.js

@@ -0,0 +1 @@
+import{useRef as a,useCallback as w}from"react";import g from"./use-input.js";const m=(e,r)=>{if(r.escape)return"escape";if(r.return)return"return";if(r.tab)return"tab";if(r.backspace)return"backspace";if(r.delete)return"delete";if(r.home)return"home";if(r.end)return"end";if(r.pageUp)return"pageup";if(r.pageDown)return"pagedown";if(r.upArrow)return"up";if(r.downArrow)return"down";if(r.leftArrow)return"left";if(r.rightArrow)return"right";if(e===" ")return"space";if(!(!e||e.length===0))return e},A=(e,r)=>{const u=m(e,r);if(u===void 0)return;const n=[];return r.ctrl&&n.push("ctrl"),r.meta&&n.push("meta"),r.shift&&n.push("shift"),n.push(u),n.join("+")},i=e=>e.trim().toLowerCase(),k=(e,r,u)=>{const{isActive:n=!0,resetAfter:c=1e3}=u??{},t=a(0),o=a(0),p=a(r);p.current=r,g(w((d,l)=>{const f=Date.now();c>0&&t.current>0&&f-o.current>c&&(t.current=0);const s=A(d,l);if(s===void 0||e.length===0)return;const h=e[t.current];if(h===void 0){t.current=0;return}if(i(s)===i(h)){t.current+=1,o.current=f,t.current>=e.length&&(t.current=0,p.current());return}t.current=0,i(s)===i(e[0]??"")&&(t.current=1,o.current=f)},[e,c]),{isActive:n})};export{k as default,k as useKeyChord};

package/dist/ink/hooks/use-linked-scroll.d.ts

@@ -0,0 +1,49 @@
+import { RefObject } from 'react';
+import { b as ScrollViewRef } from "../../packem_shared/scroll-view.d-DtpsgHLg.js";
+import "../../components/box.js";
+import 'type-fest';
+import "../../packem_shared/dom.d-B4kXbaVY.js";
+import 'yoga-layout';
+import "../../packem_shared/cursor-helpers.d-BONB9tky.js";
+import '@visulima/colorize';
+import 'cli-boxes';
+import "../../packem_shared/styles.d-cMo36xQz.js";
+type UseLinkedScrollReturn = {
+  /**
+  * Callback to pass to ScrollView's `onScroll` prop.
+  * Broadcasts the scroll position to all linked instances.
+  */
+  onScroll: (scrollOffset: number) => void;
+  /**
+  * Ref to attach to the ScrollView component.
+  * Used internally to call `scrollTo()` when other instances scroll.
+  */
+  ref: RefObject<ScrollViewRef | null>;
+};
+type LinkedScrollGroup = {
+  /**
+  * Hook that returns a ref and onScroll callback for linking a ScrollView
+  * to this group. Call once per ScrollView instance.
+  */
+  useLinkedScroll: () => UseLinkedScrollReturn;
+};
+/**
+* Creates a linked scroll group that synchronizes scroll position
+* across multiple ScrollView instances.
+* @example
+* ```tsx
+* const group = createLinkedScrollGroup();
+*
+* const PanelA = () => {
+*     const { ref, onScroll } = group.useLinkedScroll();
+*     return <ScrollView ref={ref} onScroll={onScroll}>...</ScrollView>;
+* };
+*
+* const PanelB = () => {
+*     const { ref, onScroll } = group.useLinkedScroll();
+*     return <ScrollView ref={ref} onScroll={onScroll}>...</ScrollView>;
+* };
+* ```
+*/
+declare const createLinkedScrollGroup: () => LinkedScrollGroup;
+export { LinkedScrollGroup, UseLinkedScrollReturn, createLinkedScrollGroup, createLinkedScrollGroup as default };

package/dist/ink/hooks/use-linked-scroll.js

@@ -0,0 +1 @@
+import{useRef as s,useState as u,useEffect as a,useCallback as d}from"react";const S=()=>{const r=new Set;let t=!1;return{useLinkedScroll:()=>{const l=s(null),[,c]=u(0),f={ref:l,setOffset:()=>{c(e=>e+1)}},n=s(f);return n.current=f,a(()=>{const{current:e}=n;return r.add(e),()=>{r.delete(e)}},[]),{onScroll:d(e=>{if(!t){t=!0;try{for(const o of r)o.ref!==l&&o.ref.current?.scrollTo(e)}finally{t=!1}}},[]),ref:l}}}};export{S as createLinkedScrollGroup,S as default};

package/dist/ink/hooks/use-paste.d.ts

@@ -0,0 +1,45 @@
+type Options = {
+  /**
+  * Enable or disable the paste handler. Useful when multiple components use `usePaste` and only one should be active at a time.
+  * @default true
+  */
+  isActive?: boolean;
+};
+/**
+* A React hook that calls `handler` whenever the user pastes text in the
+* terminal. Bracketed paste mode (`\x1b[?2004h`) is automatically enabled while
+* the hook is active, so pasted text arrives as a single string rather than being
+* misinterpreted as individual key presses.
+*
+* `usePaste` is the dedicated API for paste blobs. `usePaste` and `useInput` can
+* be used together in the same component; they operate on separate event
+* channels, so paste content is never forwarded to `useInput` handlers while a
+* `usePaste` handler is active.
+*
+* If no `usePaste` handler is active, Ink still forwards bracketed paste text to
+* `useInput` for backward compatibility. That fallback is deprecated and will be
+* removed in the next major version.
+*
+* ```
+* import {useInput} from '@visulima/tui/hooks/use-input';
+* import {usePaste} from '@visulima/tui/hooks/use-paste';
+*
+* const MyInput = () => {
+*   useInput((input, key) => {
+*     // Only receives typed characters and key events, not pasted text.
+*     if (key.return) {
+*       // Submit
+*     }
+*   });
+*
+*   usePaste((text) => {
+*     // Receives the full pasted string, including newlines.
+*     console.log('Pasted:', text);
+*   });
+*
+*   return …
+* };
+* ```
+*/
+declare const usePaste: (handler: (text: string) => void, options?: Options) => void;
+export { usePaste as default, usePaste };

package/dist/ink/hooks/use-paste.js

@@ -0,0 +1 @@
+import{useEffectEvent as c,useEffect as a}from"react";import{j as u}from"../../packem_shared/reconciler-CFyBVf7l.js";import{useStdinContext as m}from"./use-stdin.js";const l=(o,e={})=>{const{internal_eventEmitter:t,setBracketedPasteMode:s,setRawMode:r}=m(),f=c(o);a(()=>{if(e.isActive!==!1)return r(!0),s(!0),()=>{r(!1),s(!1)}},[e.isActive,r,s]),a(()=>{if(e.isActive===!1)return;const i=n=>{u.discreteUpdates(()=>{f(n)})};return t.on("paste",i),()=>{t.removeListener("paste",i)}},[e.isActive,t])};export{l as default,l as usePaste};

package/dist/ink/hooks/use-persistent-state.d.ts

@@ -0,0 +1,65 @@
+type PersistentStorage = {
+  /**
+  * Return the persisted JSON-encoded string for `key`, or `undefined` if
+  * nothing has been stored yet.
+  */
+  readonly read: (key: string) => string | undefined;
+  /**
+  * Persist `value` (a JSON-encoded string) for `key`. Errors are swallowed
+  * by the hook so the UI keeps working in read-only environments.
+  */
+  readonly write: (key: string, value: string) => void;
+};
+type UsePersistentStateOptions = {
+  /**
+  * Namespace used by the default file storage. Separates keys across
+  * independent applications sharing the user's home directory.
+  * @default "tui"
+  */
+  readonly namespace?: string;
+  /**
+  * Custom storage backend. When omitted, the default is a file on disk at
+  * `~/.cache/visulima-tui/<namespace>.json`.
+  */
+  readonly storage?: PersistentStorage;
+};
+/**
+* In-memory storage shared across all hook instances that use it. Useful in
+* tests and in environments without file access.
+*/
+declare const createMemoryStorage: () => PersistentStorage;
+/**
+* Default file-backed storage. Reads/writes a single JSON object per
+* namespace, keyed by `key`. The directory is created on first write and
+* updates use a temp-file + rename to avoid partial writes if the process
+* crashes mid-write. Errors are forwarded to `process.stderr.write` so they
+* are visible without crashing the UI.
+*
+* The namespace object is parsed from disk once (lazily) and kept in memory;
+* subsequent reads/writes operate on the cached object instead of re-reading
+* and re-parsing the whole file on every call.
+*/
+declare const createFileStorage: (namespace: string) => PersistentStorage;
+/**
+* `useState` that persists its value through the configured `storage`
+* backend (file on disk by default). Behaves identically to `useState` at
+* the call-site.
+*
+* Persistence happens in a commit-phase effect, **not** inside the state
+* updater — updaters must be pure (React may double-invoke them under
+* StrictMode or discard them under concurrent rendering), so writing from
+* inside one risked double or phantom disk writes. Writing after commit means
+* only values that actually render are persisted.
+*
+* **Lifecycle note:** the storage backend (resolved from `options.storage`
+* or a fresh `createFileStorage(namespace)`) is captured once on mount and
+* never replaced. Mutating `options.storage` on subsequent renders has no
+* effect — remount the hook (e.g. via a `key` prop) if you need to swap
+* backends at runtime.
+* @param key Unique identifier within the backend namespace.
+* @param initialValue Value used when the backend has no entry for `key`.
+* @param options Optional storage backend + namespace overrides.
+* @returns A `[value, setValue]` tuple. Writes flush in a post-commit effect.
+*/
+declare const usePersistentState: <T>(key: string, initialValue: T, options?: UsePersistentStateOptions) => readonly [T, (value: T | ((previous: T) => T)) => void];
+export { PersistentStorage, UsePersistentStateOptions, createFileStorage, createMemoryStorage, usePersistentState as default, usePersistentState };

package/dist/ink/hooks/use-persistent-state.js

@@ -0,0 +1,2 @@
+import{createRequire as g}from"node:module";import{useRef as m,useState as N,useEffect as b,useCallback as E}from"react";const S=g(import.meta.url),a=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,l=e=>{if(typeof a<"u"&&a.versions&&a.versions.node){const[r,s]=a.versions.node.split(".").map(Number);if(r>22||r===22&&s>=3||r===20&&s>=16)return a.getBuiltinModule(e)}return S(e)},{mkdirSync:v,writeFileSync:h,renameSync:_,readFileSync:w}=l("node:fs"),{homedir:j}=l("node:os"),f=l("node:path"),p=a,q=()=>{const e=new Map;return{read:r=>e.get(r),write:(r,s)=>{e.set(r,s)}}},O=/[/\\]/,k=e=>{if(e===""||e==="."||e===".."||O.test(e)||e.includes("\0"))throw new Error(`[visulima/tui] usePersistentState: invalid namespace ${JSON.stringify(e)} — must not be empty or contain path separators.`)},J=e=>{k(e);const r=f.join(j(),".cache","visulima-tui",`${e}.json`);let s;const i=(t,n)=>{const o=n instanceof Error?n.message:String(n);p.stderr.write(`[visulima/tui] persistent-state ${t} failed: ${o}
+`)},c=()=>{if(s!==void 0)return s;try{const t=w(r,"utf8"),n=JSON.parse(t);s=n&&typeof n=="object"?n:{}}catch(t){const n=t?.code;n!=="ENOENT"&&n!=="EACCES"&&i("read",t),s={}}return s};return{read:t=>c()[t],write:(t,n)=>{const o=f.dirname(r),u=`${r}.tmp.${p.pid}`,d=c();d[t]=n;try{v(o,{recursive:!0}),h(u,JSON.stringify(d,null,2),{encoding:"utf8",flag:"w"}),_(u,r)}catch(y){i("write",y)}}}},M=(e,r,s)=>{const i=e.read(r);if(i===void 0)return s;try{return JSON.parse(i)}catch{return s}},C=(e,r,s)=>{const i=m(void 0);i.current??=s?.storage??J(s?.namespace??"tui");const c=i.current,[t,n]=N(()=>M(c,e,r)),o=m(void 0);o.current??={key:e,value:t},b(()=>{if(!(o.current?.key===e&&Object.is(o.current.value,t)))try{c.write(e,JSON.stringify(t)),o.current={key:e,value:t}}catch{}},[e,t,c]);const u=E(d=>{n(d)},[]);return[t,u]};export{J as createFileStorage,q as createMemoryStorage,C as default,C as usePersistentState};

package/dist/ink/hooks/use-scroll-acceleration.d.ts

@@ -0,0 +1,47 @@
+type UseScrollAccelerationOptions = {
+  /**
+  * Velocity multiplier per rapid scroll event.
+  * @default 1.5
+  */
+  readonly acceleration?: number;
+  /**
+  * Velocity decay factor per tick (0-1). Lower = faster stop.
+  * @default 0.92
+  */
+  readonly decayRate?: number;
+  /**
+  * Enable or disable acceleration.
+  * @default true
+  */
+  readonly isActive?: boolean;
+  /**
+  * Maximum velocity in lines per tick.
+  * @default 20
+  */
+  readonly maxVelocity?: number;
+  /**
+  * Callback invoked with the scroll delta (signed integer lines) on each tick.
+  */
+  readonly onScroll?: (delta: number) => void;
+};
+type UseScrollAccelerationResult = {
+  /** Handle a discrete scroll event (from mouse wheel or keyboard). */
+  readonly handleScroll: (direction: "down" | "up") => void;
+  /** Whether momentum is still active (coasting after last input). */
+  readonly isCoasting: boolean;
+  /** Current velocity (positive = down, negative = up). */
+  readonly velocity: number;
+};
+/**
+* Hook providing scroll acceleration with momentum physics.
+*
+* ```tsx
+* const { handleScroll } = useScrollAcceleration({
+*     onScroll: (delta) => scrollViewRef.current?.scrollBy(delta),
+* });
+*
+* useMouseAction(); // call handleScroll("up") or handleScroll("down") on scroll events
+* ```
+*/
+declare const useScrollAcceleration: (options?: UseScrollAccelerationOptions) => UseScrollAccelerationResult;
+export { UseScrollAccelerationOptions, UseScrollAccelerationResult, useScrollAcceleration as default, useScrollAcceleration };

package/dist/ink/hooks/use-scroll-acceleration.js

@@ -0,0 +1 @@
+import{useState as y,useRef as e,useEffect as p,useCallback as C,useMemo as I}from"react";const R=100,x=16,A=.5,D=(g={})=>{const{acceleration:d=1.5,decayRate:h=.92,isActive:t=!0,maxVelocity:m=20,onScroll:v}=g,[M,l]=y(0),[n,S]=y(!1),r=e(0),b=e(0),i=e(!1),f=e(void 0),c=e(v);c.current=v,p(()=>{if(!t||!n)return;const u=()=>{if(i.current){i.current=!1;return}const a=r.current;if(Math.abs(a)<A){r.current=0,l(0),S(!1);return}r.current*=h;const s=Math.round(r.current);s!==0&&c.current?.(s),l(r.current)};return f.current=setInterval(u,x),()=>{f.current&&clearInterval(f.current)}},[t,n,h]);const w=C(u=>{if(!t){c.current?.(u==="down"?1:-1);return}const a=Date.now(),s=a-b.current,o=u==="down"?1:-1;b.current=a,s<R&&Math.sign(r.current)===o?r.current=Math.min(Math.abs(r.current*d),m)*o:r.current=o,l(r.current),S(!0),i.current=!0,c.current?.(o)},[t,d,m]);return I(()=>({handleScroll:w,isCoasting:n,velocity:M}),[w,n,M])};export{D as default,D as useScrollAcceleration};

package/dist/ink/hooks/use-scroll-input.d.ts

@@ -0,0 +1,34 @@
+type UseScrollInputOptions = {
+  /**
+  * Returns the current viewport height in lines. Called on each key event
+  * so the value is always fresh (avoids stale-closure issues with refs).
+  */
+  getViewportHeight: () => number;
+  /**
+  * Enable or disable scroll input handling.
+  * @default true
+  */
+  isActive?: boolean;
+  /**
+  * Scroll by a relative delta (in lines).
+  */
+  scrollBy: (delta: number) => void;
+  /**
+  * Jump to the bottom of the content.
+  */
+  scrollToBottom: () => void;
+  /**
+  * Jump to the top of the content.
+  */
+  scrollToTop: () => void;
+  /**
+  * Enable vim-style keybindings (j/k/g/G/u/d).
+  * @default false
+  */
+  vimBindings?: boolean;
+};
+type UseScrollInputReturn = {
+  isFocused: boolean;
+};
+declare const useScrollInput: (options: UseScrollInputOptions) => UseScrollInputReturn;
+export { UseScrollInputOptions, UseScrollInputReturn, useScrollInput as default, useScrollInput };

package/dist/ink/hooks/use-scroll-input.js

@@ -0,0 +1 @@
+import c from"./use-focus.js";import a from"./use-input.js";const h=u=>{const{getViewportHeight:e,isActive:i=!0,scrollBy:o,scrollToBottom:f,scrollToTop:n,vimBindings:s=!1}=u,{isFocused:l}=c({isActive:i});return a((t,r)=>{if(r.upArrow){o(-1);return}if(r.downArrow){o(1);return}if(r.pageUp){o(-e());return}if(r.pageDown){o(e());return}if(r.home){n();return}if(r.end){f();return}if(r.ctrl&&t==="u"){o(-Math.floor(e()/2));return}if(r.ctrl&&t==="d"){o(Math.floor(e()/2));return}if(s){if(t==="k"){o(-1);return}if(t==="j"){o(1);return}if(t==="G"&&r.shift){f();return}if(t==="g"&&!r.shift){n();return}if(t==="u"&&!r.ctrl){o(-Math.floor(e()/2));return}t==="d"&&!r.ctrl&&o(Math.floor(e()/2))}},{isActive:i}),{isFocused:l}};export{h as default,h as useScrollInput};

package/dist/ink/hooks/use-stderr.d.ts

@@ -0,0 +1,16 @@
+import 'react';
+type Props = {
+  /**
+  * Stderr stream passed to `render()` in `options.stderr` or `process.stderr` by default.
+  */
+  readonly stderr: NodeJS.WriteStream;
+  /**
+  * Write any string to stderr while preserving Ink's output. It's useful when you want to display external information outside of Ink's rendering and ensure there's no conflict between the two. It's similar to `<Static>`, except it can't accept components; it only works with strings.
+  */
+  readonly write: (data: string) => void;
+};
+/**
+* A React hook that returns the stderr stream.
+*/
+declare const useStderr: () => Props;
+export { type Props as StderrProps, useStderr as default, useStderr };

package/dist/ink/hooks/use-stderr.js

@@ -0,0 +1 @@
+import{useContext as t}from"react";import{t as o}from"../../packem_shared/stderr-context-Bvnik0hL.js";const s=()=>t(o);export{s as default,s as useStderr};

package/dist/ink/hooks/use-stdin.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from 'node:events';
+import 'react';
+type PublicProps = {
+  /**
+  * A boolean flag determining if the current `stdin` supports `setRawMode`. A component using `setRawMode` might want to use `isRawModeSupported` to nicely fall back in environments where raw mode is not supported.
+  */
+  readonly isRawModeSupported: boolean;
+  /**
+  * Ink exposes this function via own `<StdinContext>` to be able to handle Ctrl+C, that's why you should use Ink's `setRawMode` instead of `process.stdin.setRawMode`. If the `stdin` stream passed to Ink does not support setRawMode, this function does nothing.
+  */
+  readonly setRawMode: (value: boolean) => void;
+  /**
+  * The stdin stream passed to `render()` in `options.stdin`, or `process.stdin` by default. Useful if your app needs to handle user input.
+  */
+  readonly stdin: NodeJS.ReadStream;
+};
+type Props = PublicProps & {
+  readonly internal_eventEmitter: EventEmitter;
+  readonly internal_exitOnCtrlC: boolean;
+  /**
+  * Enable or disable bracketed paste mode on the terminal. When enabled, pasted text is wrapped in escape sequences that allow it to be distinguished from typed input.
+  */
+  readonly setBracketedPasteMode: (value: boolean) => void;
+};
+/**
+* A React hook that returns the stdin stream and stdin-related utilities.
+*/
+declare const useStdin: () => PublicProps;
+declare const useStdinContext: () => Props;
+export { type PublicProps as StdinProps, useStdin as default, useStdin, useStdinContext };

package/dist/ink/hooks/use-stdin.js

@@ -0,0 +1 @@
+import{useContext as t}from"react";import{e}from"../../packem_shared/stdin-context-88AhuztD.js";const n=()=>t(e),r=()=>t(e);export{n as default,n as useStdin,r as useStdinContext};

package/dist/ink/hooks/use-stdout.d.ts

@@ -0,0 +1,16 @@
+import 'react';
+type Props = {
+  /**
+  * Stdout stream passed to `render()` in `options.stdout` or `process.stdout` by default.
+  */
+  readonly stdout: NodeJS.WriteStream;
+  /**
+  * Write any string to stdout while preserving Ink's output. It's useful when you want to display external information outside of Ink's rendering and ensure there's no conflict between the two. It's similar to `<Static>`, except it can't accept components; it only works with strings.
+  */
+  readonly write: (data: string) => void;
+};
+/**
+* A React hook that returns the stdout stream where Ink renders your app.
+*/
+declare const useStdout: () => Props;
+export { type Props as StdoutProps, useStdout as default, useStdout };

package/dist/ink/hooks/use-stdout.js

@@ -0,0 +1 @@
+import{useContext as t}from"react";import{t as o}from"../../packem_shared/stdout-context-BnblEPez.js";const r=()=>t(o);export{r as default,r as useStdout};

package/dist/ink/hooks/use-stopwatch.d.ts

@@ -0,0 +1,39 @@
+type UseStopwatchOptions = {
+  /**
+  * Whether to start counting immediately.
+  * @default false
+  */
+  readonly autoStart?: boolean;
+  /**
+  * Tick interval in milliseconds.
+  * @default 1000
+  */
+  readonly interval?: number;
+};
+type UseStopwatchResult = {
+  /** Milliseconds elapsed since start (or last reset). */
+  readonly elapsed: number;
+  /** Whether the stopwatch is currently running. */
+  readonly isRunning: boolean;
+  /** Capture the current elapsed time as a lap. Returns the elapsed value. */
+  readonly lap: () => number;
+  /** Accumulated lap times. */
+  readonly laps: ReadonlyArray<number>;
+  /** Reset elapsed to 0, clear laps, and stop the stopwatch. */
+  readonly reset: () => void;
+  /** Start counting. */
+  readonly start: () => void;
+  /** Pause counting. */
+  readonly stop: () => void;
+  /** Toggle between running and stopped. */
+  readonly toggle: () => void;
+};
+/**
+* A count-up stopwatch hook built on `useAnimation`.
+*
+* ```tsx
+* const { elapsed, isRunning, start, stop, reset, lap, laps } = useStopwatch();
+* ```
+*/
+declare function useStopwatch(options?: UseStopwatchOptions): UseStopwatchResult;
+export { UseStopwatchOptions, UseStopwatchResult, useStopwatch as default, useStopwatch };

package/dist/ink/hooks/use-stopwatch.js

@@ -0,0 +1 @@
+import{useState as u,useCallback as t,useRef as b}from"react";import h from"./use-animation.js";function x(c){const{autoStart:i=!1,interval:f=1e3}=c??{},[a,e]=u(i),[p,n]=u([]),{reset:o,time:s}=h({interval:f,isActive:a}),m=t(()=>{e(!0)},[]),g=t(()=>{e(!1)},[]),d=t(()=>{e(r=>!r)},[]),v=t(()=>{e(!1),n([]),o()},[o]),l=b(s);l.current=s;const R=t(()=>{const{current:r}=l;return n(S=>[...S,r]),r},[]);return{elapsed:s,isRunning:a,lap:R,laps:p,reset:v,start:m,stop:g,toggle:d}}export{x as default,x as useStopwatch};

package/dist/ink/hooks/use-terminal-palette.d.ts

@@ -0,0 +1,20 @@
+import { T as TerminalPalette } from "../../packem_shared/terminal-palette.d-D2SQjfn-.js";
+import 'node:stream';
+type UseTerminalPaletteResult = {
+  readonly isLoading: boolean;
+  readonly isSupported: boolean;
+  readonly palette: Partial<TerminalPalette> | null;
+};
+/**
+* Hook that queries the terminal for its current color palette.
+* Returns the detected palette colors or null if not yet loaded.
+*
+* ```tsx
+* const { palette, isLoading } = useTerminalPalette();
+* if (palette?.background) {
+*     console.log("Terminal background:", palette.background);
+* }
+* ```
+*/
+declare const useTerminalPalette: () => UseTerminalPaletteResult;
+export { UseTerminalPaletteResult, useTerminalPalette as default, useTerminalPalette };

package/dist/ink/hooks/use-terminal-palette.js

@@ -0,0 +1 @@
+import{useState as o,useMemo as m,useEffect as f}from"react";import{isTerminalPaletteQuerySupported as p,queryTerminalPalette as c}from"../../packem_shared/isTerminalPaletteQuerySupported-BYzmqq9-.js";import{useStdinContext as d}from"./use-stdin.js";import y from"./use-stdout.js";const g=()=>{const{stdin:t}=d(),{stdout:e}=y(),[u,i]=o(null),[l,s]=o(!0),r=m(()=>p(),[]);return f(()=>{if(!r||!t||!e){s(!1);return}let a=!1;return(async()=>{try{const n=await c(t,e,200);a||i(n)}catch{}finally{a||s(!1)}})(),()=>{a=!0}},[r,t,e]),{isLoading:l,isSupported:r,palette:u}};export{g as default,g as useTerminalPalette};

package/dist/ink/hooks/use-text-buffer.d.ts

@@ -0,0 +1,42 @@
+type CursorPosition = {
+  readonly col: number;
+  readonly line: number;
+};
+type TextBufferState = {
+  readonly anchor: CursorPosition | null;
+  readonly cursor: CursorPosition;
+  readonly lines: ReadonlyArray<string>;
+};
+type UseTextBufferResult = {
+  readonly anchor: CursorPosition | null;
+  readonly clearSelection: () => void;
+  readonly cursor: CursorPosition;
+  readonly deleteBack: () => void;
+  readonly deleteForward: () => void;
+  readonly deleteLine: () => void;
+  readonly deleteSelection: () => void;
+  readonly deleteToLineEnd: () => void;
+  readonly deleteToLineStart: () => void;
+  readonly deleteWord: () => void;
+  readonly getSelectedText: () => string;
+  readonly hasSelection: () => boolean;
+  readonly insert: (text: string) => void;
+  readonly lines: ReadonlyArray<string>;
+  readonly moveCursor: (direction: "down" | "left" | "right" | "up", selecting?: boolean) => void;
+  readonly moveToEnd: (selecting?: boolean) => void;
+  readonly moveToLineEnd: (selecting?: boolean) => void;
+  readonly moveToLineStart: (selecting?: boolean) => void;
+  readonly moveToStart: (selecting?: boolean) => void;
+  readonly newline: () => void;
+  readonly redo: () => void;
+  readonly replaceSelection: (text: string) => void;
+  readonly selectAll: () => void;
+  readonly setValue: (value: string) => void;
+  readonly undo: () => void;
+  readonly value: string;
+};
+/**
+* Hook managing a multi-line text buffer with cursor, selection, and undo/redo.
+*/
+declare const useTextBuffer: (initialValue?: string) => UseTextBufferResult;
+export { CursorPosition, TextBufferState, UseTextBufferResult, useTextBuffer as default, useTextBuffer };

package/dist/ink/hooks/use-text-buffer.js

@@ -0,0 +1,4 @@
+import{useState as Y,useRef as T,useCallback as u,useMemo as Q}from"react";const Z=300,_=100,q=/\S+\s*$/,x=i=>{const t=i.split(`
+`);return t.length===0?[""]:t},J=i=>i.join(`
+`),h=i=>({anchor:i.anchor,cursor:{...i.cursor},lines:[...i.lines]}),b=(i,t,s)=>s?{...i,anchor:i.anchor??i.cursor,cursor:t}:{...i,anchor:null,cursor:t},U=(i,t)=>t.line<i.line||t.line===i.line&&t.col<i.col?{end:i,start:t}:{end:t,start:i},S=i=>{if(!i.anchor)return null;const{end:t,start:s}=U(i.cursor,i.anchor),a=[...i.lines],d=a[s.line].slice(0,s.col),f=a[t.line].slice(t.col);return a.splice(s.line,t.line-s.line+1,d+f),{anchor:null,cursor:s,lines:a}},M=(i,t)=>{const s=S(i)??i,a=[...s.lines],{col:d,line:f}=s.cursor,v=a[f].slice(0,d),m=a[f].slice(d),c=x(t);if(c.length===1)return a[f]=v+c[0]+m,{anchor:null,cursor:{col:d+c[0].length,line:f},lines:a};const k=v+c[0],L=c.at(-1)+m,w=c.slice(1,-1);return a.splice(f,1,k,...w,L),{anchor:null,cursor:{col:c.at(-1).length,line:f+c.length-1},lines:a}},ln=(i="")=>{const[t,s]=Y(()=>{const n=x(i);return{anchor:null,cursor:{col:n.at(-1).length,line:n.length-1},lines:n}}),a=T([]),d=T([]),f=T(0),v=T(t.cursor.col);v.current=t.cursor.col;const m=T(t);m.current=t;const c=u(n=>{const l=Date.now();l-f.current<Z&&a.current.length>0||(a.current.push(n),a.current.length>_&&a.current.shift()),d.current=[],f.current=l},[]),k=u(()=>m.current.anchor!==null,[]),L=u(()=>{const n=m.current;if(!n.anchor)return"";const{end:l,start:e}=U(n.cursor,n.anchor);if(e.line===l.line)return n.lines[e.line].slice(e.col,l.col);const r=[];r.push(n.lines[e.line].slice(e.col));for(let o=e.line+1;o<l.line;o++)r.push(n.lines[o]);return r.push(n.lines[l.line].slice(0,l.col)),r.join(`
+`)},[]),w=u(n=>{s(l=>(c(h(l)),M(l,n)))},[c]),E=u(()=>{s(n=>{c(h(n));const l=S(n)??n,e=[...l.lines],{col:r,line:o}=l.cursor,g=e[o].slice(0,r),p=e[o].slice(r);return e.splice(o,1,g,p),{anchor:null,cursor:{col:0,line:o+1},lines:e}})},[c]),j=u(()=>{s(n=>{if(n.anchor)return c(h(n)),S(n)??n;const{col:l,line:e}=n.cursor;if(l===0&&e===0)return n;c(h(n));const r=[...n.lines];if(l===0){const o=r[e-1],g=o.length;return r[e-1]=o+r[e],r.splice(e,1),{anchor:null,cursor:{col:g,line:e-1},lines:r}}return r[e]=r[e].slice(0,l-1)+r[e].slice(l),{anchor:null,cursor:{col:l-1,line:e},lines:r}})},[c]),B=u(()=>{s(n=>{if(n.anchor)return c(h(n)),S(n)??n;const{col:l,line:e}=n.cursor,r=n.lines[e];if(l===r.length&&e===n.lines.length-1)return n;c(h(n));const o=[...n.lines];return l===r.length?(o[e]=r+o[e+1],o.splice(e+1,1),{anchor:null,cursor:n.cursor,lines:o}):(o[e]=r.slice(0,l)+r.slice(l+1),{anchor:null,cursor:n.cursor,lines:o})})},[c]),C=u(()=>{s(n=>{c(h(n));const l=[...n.lines],{line:e}=n.cursor;if(l.length===1)return{anchor:null,cursor:{col:0,line:0},lines:[""]};l.splice(e,1);const r=Math.min(e,l.length-1);return{anchor:null,cursor:{col:Math.min(n.cursor.col,l[r].length),line:r},lines:l}})},[c]),y=u(()=>{s(n=>{c(h(n));const l=[...n.lines],{col:e,line:r}=n.cursor;return l[r]=l[r].slice(0,e),{...n,anchor:null,lines:l}})},[c]),A=u(()=>{s(n=>{c(h(n));const l=[...n.lines],{col:e,line:r}=n.cursor;return l[r]=l[r].slice(e),{anchor:null,cursor:{col:0,line:r},lines:l}})},[c]),D=u(()=>{s(n=>{if(c(h(n)),n.anchor)return S(n)??n;const{col:l,line:e}=n.cursor,r=n.lines[e].slice(0,l).replace(q,""),o=[...n.lines];return o[e]=r+n.lines[e].slice(l),{anchor:null,cursor:{col:r.length,line:e},lines:o}})},[c]),F=u((n,l=!1)=>{s(e=>{const{col:r,line:o}=e.cursor;let g=o,p=r;switch(n){case"down":{o<e.lines.length-1&&(g=o+1,p=Math.min(v.current,e.lines[g].length));break}case"left":{r>0?p=r-1:o>0&&(g=o-1,p=e.lines[g].length);break}case"right":{const X=e.lines[o].length;r<X?p=r+1:o<e.lines.length-1&&(g=o+1,p=0);break}case"up":{o>0&&(g=o-1,p=Math.min(v.current,e.lines[g].length));break}}return b(e,{col:p,line:g},l)})},[]),R=u((n=!1)=>{s(l=>b(l,{col:0,line:l.cursor.line},n))},[]),V=u((n=!1)=>{s(l=>b(l,{col:l.lines[l.cursor.line].length,line:l.cursor.line},n))},[]),W=u((n=!1)=>{s(l=>b(l,{col:0,line:0},n))},[]),$=u((n=!1)=>{s(l=>{const e=l.lines.length-1;return b(l,{col:l.lines[e].length,line:e},n)})},[]),z=u(()=>{s(n=>{const l=n.lines.length-1;return{...n,anchor:{col:0,line:0},cursor:{col:n.lines[l].length,line:l}}})},[]),G=u(()=>{s(n=>n.anchor?{...n,anchor:null}:n)},[]),H=u(()=>{s(n=>n.anchor?(c(h(n)),S(n)??n):n)},[c]),I=u(n=>{s(l=>{if(!l.anchor)return c(h(l)),M(l,n);c(h(l));const e=S(l)??l;return M(e,n)})},[c]),K=u(n=>{const l=x(n);s({anchor:null,cursor:{col:l.at(-1).length,line:l.length-1},lines:l}),a.current=[],d.current=[]},[]),N=u(()=>{const n=a.current.pop();n&&(d.current.push(h(m.current)),s(n))},[]),O=u(()=>{const n=d.current.pop();n&&(a.current.push(h(m.current)),s(n))},[]),P=Q(()=>J(t.lines),[t.lines]);return Q(()=>({anchor:t.anchor,clearSelection:G,cursor:t.cursor,deleteBack:j,deleteForward:B,deleteLine:C,deleteSelection:H,deleteToLineEnd:y,deleteToLineStart:A,deleteWord:D,getSelectedText:L,hasSelection:k,insert:w,lines:t.lines,moveCursor:F,moveToEnd:$,moveToLineEnd:V,moveToLineStart:R,moveToStart:W,newline:E,redo:O,replaceSelection:I,selectAll:z,setValue:K,undo:N,value:P}),[t.anchor,t.cursor,t.lines,P,G,j,B,C,H,y,A,D,L,k,w,F,$,V,R,W,E,O,I,z,K,N])};export{ln as default,ln as useTextBuffer};