@camerontaylor/paseo-protocol 0.8.0-fork.1

package/dist/search/text-match.js

@@ -0,0 +1,291 @@
+/**
+ * Ranked text matching shared by the app's pickers and the daemon's history
+ * search. A match is a tier plus the offset it was found at; lower is better on
+ * both, so callers sort ascending and never have to invent a scale.
+ *
+ * Typo tolerance is opt-in via `fuzzy`. The pickers leave it off — a combobox
+ * over a known list wants exact narrowing — while history search turns it on
+ * because the user is recalling a title from memory.
+ */
+/** Exact tiers, best to worst. The fuzzy tier always sorts after all of them. */
+const TIER_EXACT = 0;
+const TIER_WHOLE_WORD = 1;
+const TIER_PREFIX = 2;
+const TIER_WORD_START = 3;
+const TIER_SUBSTRING = 4;
+const TIER_SUBSEQUENCE = 5;
+const TIER_FUZZY = 6;
+function isWordBoundaryChar(ch) {
+    if (ch === undefined)
+        return true;
+    return !/[a-z0-9]/.test(ch);
+}
+function scoreSubstringMatch(query, text) {
+    let best = null;
+    let pos = 0;
+    while (pos <= text.length - query.length) {
+        const found = text.indexOf(query, pos);
+        if (found === -1)
+            break;
+        const before = found > 0 ? text[found - 1] : undefined;
+        const after = text[found + query.length];
+        const startsAtBoundary = found === 0 || isWordBoundaryChar(before);
+        const endsAtBoundary = after === undefined || isWordBoundaryChar(after);
+        let tier;
+        if (startsAtBoundary && endsAtBoundary) {
+            tier = TIER_WHOLE_WORD;
+        }
+        else if (found === 0) {
+            tier = TIER_PREFIX;
+        }
+        else if (startsAtBoundary) {
+            tier = TIER_WORD_START;
+        }
+        else {
+            tier = TIER_SUBSTRING;
+        }
+        if (!best || tier < best.tier || (tier === best.tier && found < best.offset)) {
+            best = { tier, offset: found };
+        }
+        pos = found + 1;
+    }
+    return best;
+}
+function scoreSubsequenceMatch(query, text) {
+    let queryIndex = 0;
+    let firstIndex = -1;
+    let lastIndex = -1;
+    for (let textIndex = 0; textIndex < text.length && queryIndex < query.length; textIndex += 1) {
+        if (text[textIndex] !== query[queryIndex])
+            continue;
+        if (firstIndex === -1)
+            firstIndex = textIndex;
+        lastIndex = textIndex;
+        queryIndex += 1;
+    }
+    if (queryIndex !== query.length || firstIndex === -1)
+        return null;
+    return { tier: TIER_SUBSEQUENCE, offset: firstIndex, spread: lastIndex - firstIndex + 1 };
+}
+/**
+ * Damerau-Levenshtein distance, abandoned as soon as every cell in a row is
+ * over budget. Bounding it is what keeps the fuzzy tier affordable to run
+ * against every word of every candidate.
+ */
+function boundedEditDistance(query, word, budget) {
+    if (Math.abs(query.length - word.length) > budget)
+        return null;
+    let twoRowsBack = [];
+    let previousRow = Array.from({ length: word.length + 1 }, (_, index) => index);
+    for (let queryIndex = 1; queryIndex <= query.length; queryIndex += 1) {
+        const currentRow = [queryIndex];
+        let rowBest = queryIndex;
+        for (let wordIndex = 1; wordIndex <= word.length; wordIndex += 1) {
+            const substitutionCost = query[queryIndex - 1] === word[wordIndex - 1] ? 0 : 1;
+            let cost = Math.min(currentRow[wordIndex - 1] + 1, previousRow[wordIndex] + 1, previousRow[wordIndex - 1] + substitutionCost);
+            const isTransposition = queryIndex > 1 &&
+                wordIndex > 1 &&
+                query[queryIndex - 1] === word[wordIndex - 2] &&
+                query[queryIndex - 2] === word[wordIndex - 1];
+            if (isTransposition) {
+                cost = Math.min(cost, twoRowsBack[wordIndex - 2] + 1);
+            }
+            currentRow.push(cost);
+            rowBest = Math.min(rowBest, cost);
+        }
+        if (rowBest > budget)
+            return null;
+        twoRowsBack = previousRow;
+        previousRow = currentRow;
+    }
+    const distance = previousRow[word.length];
+    return distance <= budget ? distance : null;
+}
+function transpositionDistance(query, word) {
+    return isAdjacentTransposition(query, word) ? 1 : null;
+}
+/** True when the two differ only by one swap of neighbouring characters. */
+function isAdjacentTransposition(query, word) {
+    if (query.length !== word.length)
+        return false;
+    let index = 0;
+    while (index < query.length && query[index] === word[index])
+        index += 1;
+    if (index >= query.length - 1)
+        return false;
+    if (query[index] !== word[index + 1] || query[index + 1] !== word[index])
+        return false;
+    return query.slice(index + 2) === word.slice(index + 2);
+}
+export function fuzzyPolicyForToken(token) {
+    if (token.length <= 3)
+        return null;
+    if (token.length === 4)
+        return { maxEdits: 1, transpositionsOnly: true };
+    if (token.length <= 7)
+        return { maxEdits: 1, transpositionsOnly: false };
+    return { maxEdits: 2, transpositionsOnly: false };
+}
+/**
+ * Words are what people mistype, so the fuzzy tier compares the query against
+ * each word rather than against the whole string — otherwise a long title's
+ * length difference alone would blow the budget.
+ */
+function scoreFuzzyMatch(query, text, policy) {
+    if (policy.maxEdits <= 0 || query.length <= policy.maxEdits)
+        return null;
+    let best = null;
+    const wordPattern = /[a-z0-9]+/g;
+    let word = wordPattern.exec(text);
+    while (word !== null) {
+        // Compare against the whole word and against its leading slices, so a typo
+        // in a prefix ("confug" for "configuration") still lands — the length gap
+        // to the full word would otherwise blow the budget on its own.
+        const candidates = new Set([
+            word[0],
+            word[0].slice(0, query.length),
+            word[0].slice(0, query.length + policy.maxEdits),
+        ]);
+        for (const candidate of candidates) {
+            const distance = policy.transpositionsOnly
+                ? transpositionDistance(query, candidate)
+                : boundedEditDistance(query, candidate, policy.maxEdits);
+            if (distance === null)
+                continue;
+            const score = { tier: TIER_FUZZY, offset: word.index, spread: distance };
+            if (!best || compareMatchScores(score, best) < 0) {
+                best = score;
+            }
+        }
+        word = wordPattern.exec(text);
+    }
+    return best;
+}
+export function scoreMatch(query, text, options = {}) {
+    if (!query)
+        return { tier: TIER_EXACT, offset: 0 };
+    const q = query.toLowerCase();
+    const t = text.toLowerCase();
+    if (t === q)
+        return { tier: TIER_EXACT, offset: 0 };
+    const substring = scoreSubstringMatch(q, t);
+    const exact = substring ?? (options.subsequence === false ? null : scoreSubsequenceMatch(q, t));
+    if (exact)
+        return exact;
+    const fuzzy = options.fuzzy;
+    return fuzzy ? scoreFuzzyMatch(q, t, fuzzy) : null;
+}
+function compactText(value) {
+    let compact = "";
+    const offsets = [];
+    for (let index = 0; index < value.length; index += 1) {
+        if (!/[a-z0-9]/i.test(value[index]))
+            continue;
+        compact += value[index].toLowerCase();
+        offsets.push(index);
+    }
+    return { value: compact, offsets };
+}
+/** Match a query against a complete displayed path, including its separators. */
+export function scorePathMatch(query, path) {
+    const direct = scoreMatch(query, path);
+    if (direct)
+        return direct;
+    const compactQuery = compactText(query);
+    const compactPath = compactText(path);
+    if (!compactQuery.value || !compactPath.value)
+        return null;
+    const compactScore = scoreMatch(compactQuery.value, compactPath.value);
+    if (!compactScore)
+        return null;
+    return {
+        ...compactScore,
+        offset: compactPath.offsets[compactScore.offset] ?? compactScore.offset,
+    };
+}
+function mergeAdjacentRanges(indices) {
+    const ranges = [];
+    for (const index of indices) {
+        const last = ranges.at(-1);
+        if (last && last.start + last.length === index) {
+            last.length += 1;
+            continue;
+        }
+        ranges.push({ start: index, length: 1 });
+    }
+    return ranges;
+}
+function wordRangeAt(text, offset) {
+    let end = offset;
+    while (end < text.length && /[a-z0-9]/.test(text[end]))
+        end += 1;
+    return { start: offset, length: Math.max(end - offset, 1) };
+}
+/**
+ * Where a score's match actually landed, so a caller can mark it. Derived from
+ * a score rather than produced alongside one: ranking touches every candidate
+ * and needs no ranges, while only the handful of rows that get rendered do.
+ *
+ * The tier decides the shape. A substring hit is one span; a subsequence hit is
+ * the scattered characters it walked; a typo hit marks the whole word, because
+ * the characters the user got wrong are not in the text to point at.
+ */
+export function matchRanges(query, text, score) {
+    if (!query)
+        return [];
+    const q = query.toLowerCase();
+    const t = text.toLowerCase();
+    if (score.tier === TIER_EXACT)
+        return [{ start: 0, length: text.length }];
+    if (score.tier === TIER_FUZZY)
+        return [wordRangeAt(t, score.offset)];
+    if (score.tier === TIER_SUBSEQUENCE) {
+        const indices = [];
+        let queryIndex = 0;
+        for (let textIndex = 0; textIndex < t.length && queryIndex < q.length; textIndex += 1) {
+            if (t[textIndex] !== q[queryIndex])
+                continue;
+            indices.push(textIndex);
+            queryIndex += 1;
+        }
+        return mergeAdjacentRanges(indices);
+    }
+    return [{ start: score.offset, length: q.length }];
+}
+export function compareMatchScores(a, b) {
+    if (a.tier !== b.tier)
+        return a.tier - b.tier;
+    if (a.offset !== b.offset)
+        return a.offset - b.offset;
+    return (a.spread ?? 0) - (b.spread ?? 0);
+}
+export function tokenizeQuery(query) {
+    return query
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((token) => token.length > 0);
+}
+export function scoreTextFields(query, fields, options = {}) {
+    const tokens = tokenizeQuery(query);
+    if (tokens.length === 0)
+        return { tier: TIER_EXACT, offset: 0, spread: 0 };
+    const aggregate = { tier: TIER_EXACT, offset: 0, spread: 0 };
+    for (const token of tokens) {
+        const fuzzy = options.typoTolerant ? fuzzyPolicyForToken(token) : null;
+        let best = null;
+        for (const field of fields) {
+            const score = scoreMatch(token, field, { fuzzy, subsequence: options.subsequence });
+            if (score && (!best || compareMatchScores(score, best) < 0)) {
+                best = score;
+            }
+        }
+        if (!best)
+            return null;
+        aggregate.tier += best.tier;
+        aggregate.offset += best.offset;
+        aggregate.spread = (aggregate.spread ?? 0) + (best.spread ?? token.length);
+    }
+    return aggregate;
+}
+//# sourceMappingURL=text-match.js.map

package/dist/ssh-transport.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_SSH_DAEMON_PORT = 6767;
+export interface SshTransportTarget {
+    host: string;
+    sshPort?: number;
+    daemonPort: number;
+}
+export declare function validatePort(value: string | number, label: string): number;
+export declare function validateSshHost(host: string): string;
+export declare function parseSshTransportUri(value: string): SshTransportTarget;
+export declare function buildSshTunnelArgs(target: SshTransportTarget): string[];
+//# sourceMappingURL=ssh-transport.d.ts.map

package/dist/ssh-transport.js

@@ -0,0 +1,72 @@
+export const DEFAULT_SSH_DAEMON_PORT = 6767;
+export function validatePort(value, label) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`${label} must be between 1 and 65535`);
+    }
+    return port;
+}
+export function validateSshHost(host) {
+    const normalized = host.trim();
+    if (!normalized)
+        throw new Error("SSH host is required");
+    if (/\s/u.test(normalized) || normalized.startsWith("-")) {
+        throw new Error("SSH host is invalid");
+    }
+    return normalized;
+}
+export function parseSshTransportUri(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch (error) {
+        throw new Error("Invalid SSH host URI", { cause: error });
+    }
+    if (url.protocol !== "ssh:" || url.password || (url.pathname !== "" && url.pathname !== "/")) {
+        throw new Error("Invalid SSH host URI");
+    }
+    if (url.hash)
+        throw new Error("SSH host URI does not support fragments");
+    for (const key of url.searchParams.keys()) {
+        if (key !== "daemonPort")
+            throw new Error(`Unsupported SSH host option: ${key}`);
+    }
+    const daemonPorts = url.searchParams.getAll("daemonPort");
+    if (daemonPorts.length > 1)
+        throw new Error("daemonPort may only be specified once");
+    const urlHostname = url.hostname;
+    const hostname = validateSshHost(urlHostname.startsWith("[") && urlHostname.endsWith("]")
+        ? urlHostname.slice(1, -1)
+        : urlHostname);
+    const username = decodeURIComponent(url.username);
+    const host = validateSshHost(username ? `${username}@${hostname}` : hostname);
+    return {
+        host,
+        ...(url.port ? { sshPort: validatePort(url.port, "SSH port") } : {}),
+        daemonPort: daemonPorts[0] === undefined
+            ? DEFAULT_SSH_DAEMON_PORT
+            : validatePort(daemonPorts[0], "Daemon port"),
+    };
+}
+export function buildSshTunnelArgs(target) {
+    const host = validateSshHost(target.host);
+    const daemonPort = validatePort(target.daemonPort, "Daemon port");
+    const args = [
+        "-T",
+        "-o",
+        "BatchMode=yes",
+        "-o",
+        "ConnectTimeout=10",
+        "-o",
+        "ClearAllForwardings=yes",
+        "-o",
+        "ExitOnForwardFailure=yes",
+    ];
+    if (target.sshPort !== undefined) {
+        args.push("-p", String(validatePort(target.sshPort, "SSH port")));
+    }
+    args.push("-W", `127.0.0.1:${daemonPort}`, host);
+    return args;
+}
+//# sourceMappingURL=ssh-transport.js.map

package/dist/terminal-activity.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const TERMINAL_ACTIVITY_STATES: readonly ["idle", "working", "attention"];
+export declare const TERMINAL_ACTIVITY_ATTENTION_REASONS: readonly ["finished", "needs_input"];
+export type TerminalActivityState = (typeof TERMINAL_ACTIVITY_STATES)[number];
+export type TerminalActivityAttentionReason = (typeof TERMINAL_ACTIVITY_ATTENTION_REASONS)[number];
+export declare const TerminalActivitySchema: z.ZodObject<{
+    state: z.ZodCatch<z.ZodEnum<{
+        idle: "idle";
+        working: "working";
+        attention: "attention";
+    }>>;
+    attentionReason: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        finished: "finished";
+        needs_input: "needs_input";
+    }>>>>;
+    changedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type TerminalActivity = z.infer<typeof TerminalActivitySchema>;
+export type TerminalActivityStatusBucket = "running" | "needs_input" | "attention";
+export declare function deriveTerminalActivityStatusBucket(activity: TerminalActivity | null | undefined): TerminalActivityStatusBucket | null;
+//# sourceMappingURL=terminal-activity.d.ts.map

package/dist/terminal-activity.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export const TERMINAL_ACTIVITY_STATES = ["idle", "working", "attention"];
+export const TERMINAL_ACTIVITY_ATTENTION_REASONS = ["finished", "needs_input"];
+export const TerminalActivitySchema = z.object({
+    // Forward-compat: a newer daemon may send a state this client doesn't know.
+    // Degrade unknown states to "idle" (no indicator, no notification) so the
+    // message still parses, instead of a strict enum rejecting the whole payload.
+    state: z.enum(TERMINAL_ACTIVITY_STATES).catch("idle"),
+    attentionReason: z.enum(TERMINAL_ACTIVITY_ATTENTION_REASONS).nullable().optional().catch(null),
+    changedAt: z.number(),
+});
+export function deriveTerminalActivityStatusBucket(activity) {
+    if (!activity)
+        return null;
+    if (activity.attentionReason === "needs_input")
+        return "needs_input";
+    if (activity.attentionReason === "finished")
+        return "attention";
+    if (activity.state === "working")
+        return "running";
+    if (activity.state === "attention")
+        return "needs_input";
+    return null;
+}
+//# sourceMappingURL=terminal-activity.js.map

package/dist/terminal-input-mode.d.ts

@@ -0,0 +1,30 @@
+export interface TerminalInputModeFeedResult {
+    changed: boolean;
+    responses: string[];
+}
+export interface TerminalInputModeState {
+    kittyKeyboardFlags: number;
+    win32InputMode: boolean;
+    applicationCursorKeys?: boolean;
+    bracketedPaste?: boolean;
+}
+export declare const DEFAULT_TERMINAL_INPUT_MODE_STATE: TerminalInputModeState;
+export declare function terminalInputModeSupportsModifiedEnter(state: TerminalInputModeState): boolean;
+export declare function terminalInputModeStatesEqual(left: TerminalInputModeState, right: TerminalInputModeState): boolean;
+export declare class TerminalInputModeTracker {
+    private kittyKeyboardFlags;
+    private win32InputMode;
+    private applicationCursorKeys;
+    private bracketedPaste;
+    private readonly kittyKeyboardStack;
+    private pending;
+    feed(data: string): TerminalInputModeFeedResult;
+    reset(): void;
+    getState(): TerminalInputModeState;
+    getKittyKeyboardFlags(): number;
+    supportsModifiedEnter(): boolean;
+    getPreamble(): string;
+    private applyKittyKeyboardSequence;
+    private applyPrivateModeSequence;
+}
+//# sourceMappingURL=terminal-input-mode.d.ts.map

package/dist/terminal-input-mode.js

@@ -0,0 +1,180 @@
+export const DEFAULT_TERMINAL_INPUT_MODE_STATE = {
+    kittyKeyboardFlags: 0,
+    win32InputMode: false,
+    applicationCursorKeys: false,
+    bracketedPaste: false,
+};
+const ESC = String.fromCharCode(0x1b);
+const APPLICATION_CURSOR_KEYS_MODE = 1;
+const WIN32_INPUT_MODE = 9001;
+const BRACKETED_PASTE_MODE = 2004;
+const CSI_INPUT_MODE_SEQUENCE = new RegExp(`${ESC}\\[(?:([<>=?]?)([0-9;]*)u|\\?([0-9;]*)([hl]))`, "g");
+const INCOMPLETE_CSI_INPUT_MODE_SEQUENCE = new RegExp(`${ESC}\\[[<>=?]?[0-9;]*$`);
+function parseFirstParam(params) {
+    const first = params.split(";")[0];
+    if (!first || !/^\d+$/.test(first)) {
+        return null;
+    }
+    return Number(first);
+}
+function parseSecondParam(params) {
+    const second = params.split(";")[1];
+    if (!second || !/^\d+$/.test(second)) {
+        return null;
+    }
+    return Number(second);
+}
+function parsePrivateModeParams(params) {
+    const modes = new Set();
+    for (const param of params.split(";")) {
+        if (/^\d+$/.test(param)) {
+            modes.add(Number(param));
+        }
+    }
+    return modes;
+}
+export function terminalInputModeSupportsModifiedEnter(state) {
+    return state.kittyKeyboardFlags > 0 || state.win32InputMode;
+}
+export function terminalInputModeStatesEqual(left, right) {
+    return (left.kittyKeyboardFlags === right.kittyKeyboardFlags &&
+        left.win32InputMode === right.win32InputMode &&
+        Boolean(left.applicationCursorKeys) === Boolean(right.applicationCursorKeys) &&
+        Boolean(left.bracketedPaste) === Boolean(right.bracketedPaste));
+}
+export class TerminalInputModeTracker {
+    constructor() {
+        this.kittyKeyboardFlags = 0;
+        this.win32InputMode = false;
+        this.applicationCursorKeys = false;
+        this.bracketedPaste = false;
+        this.kittyKeyboardStack = [];
+        this.pending = "";
+    }
+    feed(data) {
+        if (data.length === 0) {
+            return { changed: false, responses: [] };
+        }
+        const text = `${this.pending}${data}`;
+        this.pending = "";
+        let changed = false;
+        const responses = [];
+        let consumedUntil = 0;
+        CSI_INPUT_MODE_SEQUENCE.lastIndex = 0;
+        for (;;) {
+            const match = CSI_INPUT_MODE_SEQUENCE.exec(text);
+            if (!match) {
+                break;
+            }
+            consumedUntil = CSI_INPUT_MODE_SEQUENCE.lastIndex;
+            if (match[4]) {
+                changed = this.applyPrivateModeSequence(match[3] ?? "", match[4]) || changed;
+                continue;
+            }
+            const result = this.applyKittyKeyboardSequence(match[1] ?? "", match[2] ?? "");
+            changed = changed || result.changed;
+            responses.push(...result.responses);
+        }
+        const tail = text.slice(consumedUntil);
+        const pendingStart = tail.lastIndexOf(`${ESC}[`);
+        if (pendingStart >= 0) {
+            const pending = tail.slice(pendingStart);
+            if (INCOMPLETE_CSI_INPUT_MODE_SEQUENCE.test(pending)) {
+                this.pending = pending;
+            }
+        }
+        return { changed, responses };
+    }
+    reset() {
+        this.kittyKeyboardFlags = 0;
+        this.win32InputMode = false;
+        this.applicationCursorKeys = false;
+        this.bracketedPaste = false;
+        this.kittyKeyboardStack.length = 0;
+        this.pending = "";
+    }
+    getState() {
+        return {
+            kittyKeyboardFlags: this.kittyKeyboardFlags,
+            win32InputMode: this.win32InputMode,
+            applicationCursorKeys: this.applicationCursorKeys,
+            bracketedPaste: this.bracketedPaste,
+        };
+    }
+    getKittyKeyboardFlags() {
+        return this.kittyKeyboardFlags;
+    }
+    supportsModifiedEnter() {
+        return terminalInputModeSupportsModifiedEnter(this.getState());
+    }
+    getPreamble() {
+        const parts = [];
+        if (this.kittyKeyboardFlags > 0) {
+            parts.push(`\x1b[=${this.kittyKeyboardFlags};1u`);
+        }
+        if (this.win32InputMode) {
+            parts.push("\x1b[?9001h");
+        }
+        if (this.applicationCursorKeys) {
+            parts.push("\x1b[?1h");
+        }
+        if (this.bracketedPaste) {
+            parts.push("\x1b[?2004h");
+        }
+        return parts.join("");
+    }
+    applyKittyKeyboardSequence(prefix, params) {
+        const previousFlags = this.kittyKeyboardFlags;
+        switch (prefix) {
+            case ">": {
+                this.kittyKeyboardStack.push(this.kittyKeyboardFlags);
+                this.kittyKeyboardFlags = parseFirstParam(params) ?? 1;
+                break;
+            }
+            case "=": {
+                const mode = parseSecondParam(params) ?? 1;
+                this.kittyKeyboardFlags = mode === 0 ? 0 : (parseFirstParam(params) ?? 0);
+                break;
+            }
+            case "<": {
+                const count = Math.max(1, parseFirstParam(params) ?? 1);
+                for (let index = 0; index < count; index += 1) {
+                    this.kittyKeyboardFlags = this.kittyKeyboardStack.pop() ?? 0;
+                }
+                break;
+            }
+            case "?":
+                return {
+                    changed: false,
+                    responses: [`\x1b[?${this.kittyKeyboardFlags}u`],
+                };
+            default:
+                return { changed: false, responses: [] };
+        }
+        return {
+            changed: this.kittyKeyboardFlags !== previousFlags,
+            responses: [],
+        };
+    }
+    applyPrivateModeSequence(params, final) {
+        const modes = parsePrivateModeParams(params);
+        let changed = false;
+        if (modes.has(WIN32_INPUT_MODE)) {
+            const previous = this.win32InputMode;
+            this.win32InputMode = final === "h";
+            changed = this.win32InputMode !== previous || changed;
+        }
+        if (modes.has(APPLICATION_CURSOR_KEYS_MODE)) {
+            const previous = this.applicationCursorKeys;
+            this.applicationCursorKeys = final === "h";
+            changed = this.applicationCursorKeys !== previous || changed;
+        }
+        if (modes.has(BRACKETED_PASTE_MODE)) {
+            const previous = this.bracketedPaste;
+            this.bracketedPaste = final === "h";
+            changed = this.bracketedPaste !== previous || changed;
+        }
+        return changed;
+    }
+}
+//# sourceMappingURL=terminal-input-mode.js.map

package/dist/terminal-key-input.d.ts

@@ -0,0 +1,13 @@
+import type { TerminalInputModeState } from "./terminal-input-mode.js";
+export interface TerminalKeyInput {
+    key: string;
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+}
+export interface TerminalKeyInputEncodingOptions {
+    inputMode?: TerminalInputModeState;
+}
+export declare function encodeTerminalKeyInput(input: TerminalKeyInput, options?: TerminalKeyInputEncodingOptions): string;
+//# sourceMappingURL=terminal-key-input.d.ts.map