@visulima/ansi 4.0.0-alpha.8 → 4.0.0

package/dist/passthrough.d.ts

@@ -1,77 +1,78 @@
 /**
- * Default value for the `limit` parameter in {@link screenPassthrough}, indicating no chunking.
- * When this value is used (or any value <= 0), the passthrough sequence is not split into smaller chunks.
- */
-export declare const SCREEN_MAX_LEN_DEFAULT: number;
+* Default value for the `limit` parameter in {@link screenPassthrough}, indicating no chunking.
+* When this value is used (or any value <= 0), the passthrough sequence is not split into smaller chunks.
+*/
+declare const SCREEN_MAX_LEN_DEFAULT: number;
 /**
- * A typical limit for string sequences in GNU Screen (e.g., 768 bytes).
- * This constant can be used as a practical value for the `limit` parameter in {@link screenPassthrough}
- * to avoid issues with Screen's internal buffers, though the function itself defaults to no limit.
- * It's provided for informational purposes and as a suggested practical chunking limit.
- */
-export declare const SCREEN_TYPICAL_LIMIT: number;
+* A typical limit for string sequences in GNU Screen (e.g., 768 bytes).
+* This constant can be used as a practical value for the `limit` parameter in {@link screenPassthrough}
+* to avoid issues with Screen's internal buffers, though the function itself defaults to no limit.
+* It's provided for informational purposes and as a suggested practical chunking limit.
+*/
+declare const SCREEN_TYPICAL_LIMIT: number;
 /**
- * Wraps a given ANSI escape sequence in a DCS (Device Control String) passthrough sequence
- * specifically for GNU Screen. This allows raw escape sequences to be sent to the
- * terminal emulator that is hosting Screen, bypassing Screen's own interpretation.
- *
- * The basic format is: `DCS <data> ST` (where `DCS` is `ESC P` and `ST` is `ESC \`).
- *
- * GNU Screen has limitations on the length of string sequences it can handle (often around 768 bytes).
- * This function can optionally chunk the input `sequence` into smaller parts, each wrapped
- * in its own `DCS...ST` sequence, to work around this limitation.
- * @param sequence The ANSI escape sequence string to be wrapped.
- * @param limit The maximum length for each chunk of the `sequence` before it's wrapped.
- * If `0` or a negative number, the sequence is not chunked. Defaults to {@link SCREEN_MAX_LEN_DEFAULT} (0).
- * Consider using {@link SCREEN_TYPICAL_LIMIT} (768) for practical chunking with Screen.
- * @returns The wrapped string, possibly chunked into multiple `DCS...ST` sequences if `limit` is positive and the `sequence` exceeds it.
- * @see {@link https://www.gnu.org/software/screen/manual/screen.html#String-Escapes} GNU Screen Manual - String Escapes.
- * @example
- * ```typescript
- * import { screenPassthrough, SCREEN_TYPICAL_LIMIT } from \'@visulima/ansi/passthrough\';
- * import { cursorShow, cursorHide } from \'@visulima/ansi/cursor\';
- *
- * const longSequence = cursorHide + "Some very long output..." + cursorShow;
- *
- * // No chunking (default behavior if sequence is short enough or limit is 0)
- * const passthrough1 = screenPassthrough(cursorHide);
- * console.log(JSON.stringify(passthrough1)); // "\u001bP?25l\u001b\\"
- *
- * // With chunking, assuming SCREEN_TYPICAL_LIMIT is small for demonstration
- * const limitedPassthrough = screenPassthrough(longSequence, 10); // Hypothetical small limit
- * // Example output if longSequence was "0123456789abcde" and limit 10:
- * // "\u001bP0123456789\u001b\\\u001bPabcde\u001b\\"
- * console.log(JSON.stringify(limitedPassthrough));
- * ```
- */
-export declare const screenPassthrough: (sequence: string, limit?: number) => string;
+* Wraps a given ANSI escape sequence in a DCS (Device Control String) passthrough sequence
+* specifically for GNU Screen. This allows raw escape sequences to be sent to the
+* terminal emulator that is hosting Screen, bypassing Screen's own interpretation.
+*
+* The basic format is: `DCS <data> ST` (where `DCS` is `ESC P` and `ST` is `ESC \`).
+*
+* GNU Screen has limitations on the length of string sequences it can handle (often around 768 bytes).
+* This function can optionally chunk the input `sequence` into smaller parts, each wrapped
+* in its own `DCS...ST` sequence, to work around this limitation.
+* @param sequence The ANSI escape sequence string to be wrapped.
+* @param limit The maximum length for each chunk of the `sequence` before it's wrapped.
+* If `0` or a negative number, the sequence is not chunked. Defaults to {@link SCREEN_MAX_LEN_DEFAULT} (0).
+* Consider using {@link SCREEN_TYPICAL_LIMIT} (768) for practical chunking with Screen.
+* @returns The wrapped string, possibly chunked into multiple `DCS...ST` sequences if `limit` is positive and the `sequence` exceeds it.
+* @see {@link https://www.gnu.org/software/screen/manual/screen.html#String-Escapes} GNU Screen Manual - String Escapes.
+* @example
+* ```typescript
+* import { screenPassthrough, SCREEN_TYPICAL_LIMIT } from \'@visulima/ansi/passthrough\';
+* import { cursorShow, cursorHide } from \'@visulima/ansi/cursor\';
+*
+* const longSequence = cursorHide + "Some very long output..." + cursorShow;
+*
+* // No chunking (default behavior if sequence is short enough or limit is 0)
+* const passthrough1 = screenPassthrough(cursorHide);
+* console.log(JSON.stringify(passthrough1)); // "\u001bP?25l\u001b\\"
+*
+* // With chunking, assuming SCREEN_TYPICAL_LIMIT is small for demonstration
+* const limitedPassthrough = screenPassthrough(longSequence, 10); // Hypothetical small limit
+* // Example output if longSequence was "0123456789abcde" and limit 10:
+* // "\u001bP0123456789\u001b\\\u001bPabcde\u001b\\"
+* console.log(JSON.stringify(limitedPassthrough));
+* ```
+*/
+declare const screenPassthrough: (sequence: string, limit?: number) => string;
 /**
- * Wraps a given ANSI escape sequence in a special DCS (Device Control String) passthrough sequence
- * designed for tmux (Terminal Multiplexer). This allows raw escape sequences to be sent to the
- * terminal emulator hosting tmux, bypassing tmux's own interpretation.
- *
- * The format is: `DCS tmux ; <escaped-data> ST`
- * (where `DCS` is `ESC P`, and `ST` is `ESC \`).
- *
- * The `<escaped-data>` is the original `sequence` with all occurrences of the ESC character (`\u001B`)
- * doubled (i.e., `ESC` becomes `ESC ESC`).
- *
- * **Note:** For this to work, the tmux option `allow-passthrough` must be enabled (`on`) in the tmux configuration.
- * By default, it might be off.
- * @param sequence The ANSI escape sequence string to be wrapped and properly escaped for tmux.
- * @returns The wrapped and escaped string suitable for tmux passthrough.
- * @see {@link https://github.com/tmux/tmux/wiki/FAQ#what-is-the-passthrough-escape-sequence-and-how-do-i-use-it} Tmux FAQ on Passthrough.
- * @example
- * ```typescript
- * import { tmuxPassthrough } from \'@visulima/ansi/passthrough\';
- * import { cursorShow } from \'@visulima/ansi/cursor\';
- *
- * const originalSequence = cursorShow; // e.g., "\u001b[?25h"
- * const passthrough = tmuxPassthrough(originalSequence);
- *
- * // Expected: "\u001bPtmux;\u001b\u001b[?25h\u001b\\"
- * // (ESC P tmux ; ESC ESC [ ? 2 5 h ESC \)
- * console.log(JSON.stringify(passthrough));
- * ```
- */
-export declare const tmuxPassthrough: (sequence: string) => string;
+* Wraps a given ANSI escape sequence in a special DCS (Device Control String) passthrough sequence
+* designed for tmux (Terminal Multiplexer). This allows raw escape sequences to be sent to the
+* terminal emulator hosting tmux, bypassing tmux's own interpretation.
+*
+* The format is: `DCS tmux ; <escaped-data> ST`
+* (where `DCS` is `ESC P`, and `ST` is `ESC \`).
+*
+* The `<escaped-data>` is the original `sequence` with all occurrences of the ESC character (`\u001B`)
+* doubled (i.e., `ESC` becomes `ESC ESC`).
+*
+* **Note:** For this to work, the tmux option `allow-passthrough` must be enabled (`on`) in the tmux configuration.
+* By default, it might be off.
+* @param sequence The ANSI escape sequence string to be wrapped and properly escaped for tmux.
+* @returns The wrapped and escaped string suitable for tmux passthrough.
+* @see {@link https://github.com/tmux/tmux/wiki/FAQ#what-is-the-passthrough-escape-sequence-and-how-do-i-use-it} Tmux FAQ on Passthrough.
+* @example
+* ```typescript
+* import { tmuxPassthrough } from \'@visulima/ansi/passthrough\';
+* import { cursorShow } from \'@visulima/ansi/cursor\';
+*
+* const originalSequence = cursorShow; // e.g., "\u001b[?25h"
+* const passthrough = tmuxPassthrough(originalSequence);
+*
+* // Expected: "\u001bPtmux;\u001b\u001b[?25h\u001b\\"
+* // (ESC P tmux ; ESC ESC [ ? 2 5 h ESC \)
+* console.log(JSON.stringify(passthrough));
+* ```
+*/
+declare const tmuxPassthrough: (sequence: string) => string;
+export { SCREEN_MAX_LEN_DEFAULT, SCREEN_TYPICAL_LIMIT, screenPassthrough, tmuxPassthrough };

package/dist/passthrough.js

@@ -1,29 +1 @@
-import { a as ST, D as DCS, E as ESC } from './packem_shared/constants-CE7WkXh_.js';
-
-const SCREEN_MAX_LEN_DEFAULT = 0;
-const SCREEN_TYPICAL_LIMIT = 768;
-const screenPassthrough = (sequence, limit = SCREEN_MAX_LEN_DEFAULT) => {
-  let result = DCS;
-  if (limit > 0 && sequence.length > limit) {
-    for (let index = 0; index < sequence.length; index += limit) {
-      const end = Math.min(index + limit, sequence.length);
-      result += sequence.slice(index, end);
-      if (end < sequence.length) {
-        result += ST + DCS;
-      }
-    }
-  } else {
-    result += sequence;
-  }
-  result += ST;
-  return result;
-};
-const tmuxPassthrough = (sequence) => {
-  let escapedSequence = "";
-  for (const element of sequence) {
-    escapedSequence += element === ESC ? ESC + ESC : element;
-  }
-  return `${DCS}tmux;${escapedSequence}${ST}`;
-};
-
-export { SCREEN_MAX_LEN_DEFAULT, SCREEN_TYPICAL_LIMIT, screenPassthrough, tmuxPassthrough };
+import{ST as r,DCS as s,ESC as h}from"./constants.js";const E=0,g=768,u=(e,t=E)=>{let n=s;if(t>0&&e.length>t)for(let l=0;l<e.length;l+=t){const o=Math.min(l+t,e.length);n+=e.slice(l,o),o<e.length&&(n+=r+s)}else n+=e;return n+=r,n},m=e=>{const t=e.replaceAll(h,h+h);return`${s}tmux;${t}${r}`};export{E as SCREEN_MAX_LEN_DEFAULT,g as SCREEN_TYPICAL_LIMIT,u as screenPassthrough,m as tmuxPassthrough};

package/dist/paste.d.ts

@@ -0,0 +1,23 @@
+/**
+* Marker a terminal emits immediately before pasted text when bracketed paste
+* mode is enabled.
+*
+* Sequence: `CSI 200 ~`
+* @see {@link https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Bracketed-Paste-Mode}
+*/
+declare const bracketedPasteStart: string;
+/**
+* Marker a terminal emits immediately after pasted text when bracketed paste
+* mode is enabled.
+*
+* Sequence: `CSI 201 ~`
+*/
+declare const bracketedPasteEnd: string;
+/**
+* Wraps `text` in the bracketed-paste start/end markers, mirroring how a
+* terminal delivers pasted content to an application.
+* @param text The text to wrap.
+* @returns `text` surrounded by {@link bracketedPasteStart} and {@link bracketedPasteEnd}.
+*/
+declare const wrapBracketedPaste: (text: string) => string;
+export { bracketedPasteEnd, bracketedPasteStart, wrapBracketedPaste };

package/dist/paste.js

@@ -0,0 +1 @@
+import{CSI as t}from"./constants.js";const a=`${t}200~`,r=`${t}201~`,c=e=>`${a}${e}${r}`;export{r as bracketedPasteEnd,a as bracketedPasteStart,c as wrapBracketedPaste};

package/dist/progress.d.ts

@@ -1,41 +1,42 @@
 /**
- * Resets the progress bar to its default state (hidden).
- *
- * Sequence: `OSC 9 ; 4 ; 0 BEL`
- * @see {@link https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences}
- */
-export declare const resetProgressBar: string;
+* Resets the progress bar to its default state (hidden).
+*
+* Sequence: `OSC 9 ; 4 ; 0 BEL`
+* @see {@link https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences}
+*/
+declare const resetProgressBar: string;
 /**
- * Returns a sequence for setting the progress bar to a specific percentage (0-100) in the "default" state.
- *
- * Sequence: `OSC 9 ; 4 ; 1 ; Percentage BEL`
- * @param percentage The progress percentage (0-100, clamped automatically)
- * @returns The progress bar sequence
- * @see {@link https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences}
- */
-export declare const setProgressBar: (percentage: number) => string;
+* Returns a sequence for setting the progress bar to a specific percentage (0-100) in the "default" state.
+*
+* Sequence: `OSC 9 ; 4 ; 1 ; Percentage BEL`
+* @param percentage The progress percentage (0-100, clamped automatically)
+* @returns The progress bar sequence
+* @see {@link https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences}
+*/
+declare const setProgressBar: (percentage: number) => string;
 /**
- * Returns a sequence for setting the progress bar to a specific percentage (0-100) in the "Error" state.
- *
- * Sequence: `OSC 9 ; 4 ; 2 ; Percentage BEL`
- * @param percentage The progress percentage (0-100, clamped automatically)
- * @returns The error progress bar sequence
- * @see {@link https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences}
- */
-export declare const setErrorProgressBar: (percentage: number) => string;
+* Returns a sequence for setting the progress bar to a specific percentage (0-100) in the "Error" state.
+*
+* Sequence: `OSC 9 ; 4 ; 2 ; Percentage BEL`
+* @param percentage The progress percentage (0-100, clamped automatically)
+* @returns The error progress bar sequence
+* @see {@link https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences}
+*/
+declare const setErrorProgressBar: (percentage: number) => string;
 /**
- * Sets the progress bar to the indeterminate state.
- *
- * Sequence: `OSC 9 ; 4 ; 3 BEL`
- * @see {@link https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences}
- */
-export declare const setIndeterminateProgressBar: string;
+* Sets the progress bar to the indeterminate state.
+*
+* Sequence: `OSC 9 ; 4 ; 3 BEL`
+* @see {@link https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences}
+*/
+declare const setIndeterminateProgressBar: string;
 /**
- * Returns a sequence for setting the progress bar to a specific percentage (0-100) in the "Warning" state.
- *
- * Sequence: `OSC 9 ; 4 ; 4 ; Percentage BEL`
- * @param percentage The progress percentage (0-100, clamped automatically)
- * @returns The warning progress bar sequence
- * @see {@link https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences}
- */
-export declare const setWarningProgressBar: (percentage: number) => string;
+* Returns a sequence for setting the progress bar to a specific percentage (0-100) in the "Warning" state.
+*
+* Sequence: `OSC 9 ; 4 ; 4 ; Percentage BEL`
+* @param percentage The progress percentage (0-100, clamped automatically)
+* @returns The warning progress bar sequence
+* @see {@link https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences}
+*/
+declare const setWarningProgressBar: (percentage: number) => string;
+export { resetProgressBar, setErrorProgressBar, setIndeterminateProgressBar, setProgressBar, setWarningProgressBar };

package/dist/progress.js

@@ -0,0 +1 @@
+import{OSC as s,BEL as e}from"./constants.js";const a=`${s}9;4;0${e}`,o=r=>{const t=Math.min(Math.max(0,r),100);return`${s}9;4;1;${String(t)}${e}`},$=r=>{const t=Math.min(Math.max(0,r),100);return`${s}9;4;2;${String(t)}${e}`},g=`${s}9;4;3${e}`,i=r=>{const t=Math.min(Math.max(0,r),100);return`${s}9;4;4;${String(t)}${e}`};export{a as resetProgressBar,$ as setErrorProgressBar,g as setIndeterminateProgressBar,o as setProgressBar,i as setWarningProgressBar};

package/dist/reset.d.ts

@@ -1,26 +1,27 @@
 /**
- * The ANSI escape sequence for Reset Initial State (RIS).
- * This command attempts to reset the terminal to its power-up state or initial configuration.
- * The exact behavior can vary between terminal emulators, but it typically includes:
- * - Resetting graphic rendition (SGR parameters) to default.
- * - Clearing the screen.
- * - Moving the cursor to the top-left (home position).
- * - Resetting character sets.
- * - Resetting tab stops.
- * - Resetting modes (like DECAWM, DECOM) to their defaults.
- *
- * Sequence: `ESC c`
- *
- * This is a more comprehensive reset than `CSI 0 m` (which only resets SGR) or `CSI 2 J` (which only clears the screen).
- * It is often referred to as a "hard reset".
- * @see {@link https://vt100.net/docs/vt510-rm/RIS.html VT510 RIS Documentation}
- * @see {@link https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Reset} Xterm Control Sequences - Reset
- */
-export declare const RESET_INITIAL_STATE: string;
+* The ANSI escape sequence for Reset Initial State (RIS).
+* This command attempts to reset the terminal to its power-up state or initial configuration.
+* The exact behavior can vary between terminal emulators, but it typically includes:
+* - Resetting graphic rendition (SGR parameters) to default.
+* - Clearing the screen.
+* - Moving the cursor to the top-left (home position).
+* - Resetting character sets.
+* - Resetting tab stops.
+* - Resetting modes (like DECAWM, DECOM) to their defaults.
+*
+* Sequence: `ESC c`
+*
+* This is a more comprehensive reset than `CSI 0 m` (which only resets SGR) or `CSI 2 J` (which only clears the screen).
+* It is often referred to as a "hard reset".
+* @see {@link https://vt100.net/docs/vt510-rm/RIS.html VT510 RIS Documentation}
+* @see {@link https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Reset} Xterm Control Sequences - Reset
+*/
+declare const RESET_INITIAL_STATE: string;
 /**
- * Alias for {@link RESET_INITIAL_STATE} (Reset Initial State).
- *
- * Provides a shorter name for the RIS sequence `ESC c`.
- * @see {@link RESET_INITIAL_STATE}
- */
-export declare const RIS: string;
+* Alias for {@link RESET_INITIAL_STATE} (Reset Initial State).
+*
+* Provides a shorter name for the RIS sequence `ESC c`.
+* @see {@link RESET_INITIAL_STATE}
+*/
+declare const RIS: string;
+export { RESET_INITIAL_STATE, RIS };

package/dist/reset.js

@@ -1,4 +1 @@
-const RESET_INITIAL_STATE = "\x1Bc";
-const RIS = RESET_INITIAL_STATE;
-
-export { RESET_INITIAL_STATE, RIS };
+const I="\x1Bc",T="\x1Bc";export{I as RESET_INITIAL_STATE,T as RIS};