neon 2.47.0 → 3.1.0

package/dist/psql/io/lineEditor/buffer.js

@@ -1,325 +1,244 @@
+//#region src/psql/io/lineEditor/buffer.ts
 /**
- * Pure line-buffer state for the psql line editor.
- *
- * We avoid an actual gap buffer because edited lines are short (~100 chars
- * typical, a few KB worst case for pasted SQL) and JavaScript string
- * concatenation is fast enough at that scale. The "buffer-ish" API still
- * exposes insert/delete-at-cursor primitives so callers stay code-point
- * aware rather than byte aware.
- *
- * Everything in this module operates on Unicode *code points*. Internally
- * we store the line as an array of code-point strings (each element is one
- * scalar value, typically one UTF-16 code unit but two for astral chars).
- * The `cursor` is an index into that array, in the range `[0, length]`.
- *
- * Editing primitives mutate the state in place and push the previous
- * snapshot onto the undo stack. Killed text (^K, ^U, ^W) is appended to
- * the most recent kill ring entry when killing continues in the same
- * direction; yank pulls from the most recent entry.
- *
- * No I/O, no rendering, no terminal awareness — that lives in
- * `keymap.ts` / `index.ts`. Tests cover this module exhaustively.
- */
-/**
- * Encode a string as an array of code-point characters. Each element is
- * one Unicode scalar (`"A"`, `"é"`, `"\u{1F600}"`). This lets cursor
- * arithmetic stay code-point-aligned without dealing with surrogate pairs
- * at every callsite.
- */
+* Encode a string as an array of code-point characters. Each element is
+* one Unicode scalar (`"A"`, `"é"`, `"\u{1F600}"`). This lets cursor
+* arithmetic stay code-point-aligned without dealing with surrogate pairs
+* at every callsite.
+*/
 const toCodePoints = (s) => Array.from(s);
 /**
- * Pure line buffer plus kill ring plus undo. Used by the keymap layer.
- */
-export class LineBuffer {
-    constructor(initial = "", cursor) {
-        /** One code point per element. */
-        this.chars = [];
-        /** Code-point index in `[0, chars.length]`. */
-        this._cursor = 0;
-        /** Most-recent-first ring of killed text. Bounded to keep memory sane. */
-        this.killRing = [];
-        /** Index into killRing for the next yank-pop (^Y / Alt-Y). */
-        this.yankIndex = -1;
-        /** Direction of the previous kill so consecutive kills concatenate. */
-        this.lastKill = "none";
-        /** Snapshots for ^_ / undo. */
-        this.undoStack = [];
-        this.chars = toCodePoints(initial);
-        this._cursor =
-            cursor === undefined ? this.chars.length : this.clampCursor(cursor);
-    }
-    // -------------------------------------------------------------------------
-    // Accessors
-    // -------------------------------------------------------------------------
-    get text() {
-        return this.chars.join("");
-    }
-    get cursor() {
-        return this._cursor;
-    }
-    get length() {
-        return this.chars.length;
-    }
-    snapshot() {
-        return { text: this.text, cursor: this._cursor };
-    }
-    restore(snap) {
-        this.chars = toCodePoints(snap.text);
-        this._cursor = this.clampCursor(snap.cursor);
-        this.lastKill = "none";
-    }
-    /**
-     * Replace the entire buffer in one go. Used when navigating history or
-     * accepting a completion. Does NOT push an undo entry on its own — call
-     * `pushUndo()` first if you want to record the previous state.
-     */
-    setText(text, cursor) {
-        this.chars = toCodePoints(text);
-        this._cursor =
-            cursor === undefined ? this.chars.length : this.clampCursor(cursor);
-        this.lastKill = "none";
-    }
-    // -------------------------------------------------------------------------
-    // Cursor movement (all in code points, never bytes / UTF-16 units)
-    // -------------------------------------------------------------------------
-    moveLeft() {
-        if (this._cursor > 0)
-            this._cursor--;
-        this.lastKill = "none";
-    }
-    moveRight() {
-        if (this._cursor < this.chars.length)
-            this._cursor++;
-        this.lastKill = "none";
-    }
-    moveHome() {
-        this._cursor = 0;
-        this.lastKill = "none";
-    }
-    moveEnd() {
-        this._cursor = this.chars.length;
-        this.lastKill = "none";
-    }
-    /**
-     * Move left over one word. Word ≙ run of alphanumerics. Skip the
-     * non-alphanumerics immediately to the left first (matches readline's
-     * `M-b`). Pure stdlib `\w` is locale-sensitive in some runtimes; we
-     * use a `RegExp` against the actual code-point string.
-     */
-    moveWordLeft() {
-        let i = this._cursor;
-        while (i > 0 && !isWordChar(this.chars[i - 1]))
-            i--;
-        while (i > 0 && isWordChar(this.chars[i - 1]))
-            i--;
-        this._cursor = i;
-        this.lastKill = "none";
-    }
-    moveWordRight() {
-        let i = this._cursor;
-        while (i < this.chars.length && !isWordChar(this.chars[i]))
-            i++;
-        while (i < this.chars.length && isWordChar(this.chars[i]))
-            i++;
-        this._cursor = i;
-        this.lastKill = "none";
-    }
-    // -------------------------------------------------------------------------
-    // Insertion / deletion
-    // -------------------------------------------------------------------------
-    /** Insert a string at the cursor (split into code points first). */
-    insert(s) {
-        if (s.length === 0)
-            return;
-        this.pushUndo();
-        const cps = toCodePoints(s);
-        this.chars.splice(this._cursor, 0, ...cps);
-        this._cursor += cps.length;
-        this.lastKill = "none";
-    }
-    /** Backspace: delete the code point to the left of cursor. */
-    deleteLeft() {
-        if (this._cursor === 0)
-            return;
-        this.pushUndo();
-        this.chars.splice(this._cursor - 1, 1);
-        this._cursor--;
-        this.lastKill = "none";
-    }
-    /** Delete the code point to the right of cursor. */
-    deleteRight() {
-        if (this._cursor === this.chars.length)
-            return;
-        this.pushUndo();
-        this.chars.splice(this._cursor, 1);
-        this.lastKill = "none";
-    }
-    // -------------------------------------------------------------------------
-    // Kill ring operations
-    // -------------------------------------------------------------------------
-    /** ^K: kill from cursor to end-of-line. Appends if previous kill was forward. */
-    killToEnd() {
-        if (this._cursor === this.chars.length)
-            return;
-        this.pushUndo();
-        const killed = this.chars.slice(this._cursor).join("");
-        this.chars.length = this._cursor;
-        this.recordKill(killed, "forward");
-    }
-    /** ^U: kill from start-of-line to cursor. */
-    killToStart() {
-        if (this._cursor === 0)
-            return;
-        this.pushUndo();
-        const killed = this.chars.slice(0, this._cursor).join("");
-        this.chars.splice(0, this._cursor);
-        this._cursor = 0;
-        this.recordKill(killed, "backward");
-    }
-    /** ^W: kill the word (backward) to the left of cursor. */
-    killWordLeft() {
-        if (this._cursor === 0)
-            return;
-        let i = this._cursor;
-        while (i > 0 && !isWordChar(this.chars[i - 1]))
-            i--;
-        while (i > 0 && isWordChar(this.chars[i - 1]))
-            i--;
-        if (i === this._cursor)
-            return;
-        this.pushUndo();
-        const killed = this.chars.slice(i, this._cursor).join("");
-        this.chars.splice(i, this._cursor - i);
-        this._cursor = i;
-        this.recordKill(killed, "backward");
-    }
-    /** M-d: kill the word (forward) starting at cursor. */
-    killWordRight() {
-        if (this._cursor === this.chars.length)
-            return;
-        let i = this._cursor;
-        while (i < this.chars.length && !isWordChar(this.chars[i]))
-            i++;
-        while (i < this.chars.length && isWordChar(this.chars[i]))
-            i++;
-        if (i === this._cursor)
-            return;
-        this.pushUndo();
-        const killed = this.chars.slice(this._cursor, i).join("");
-        this.chars.splice(this._cursor, i - this._cursor);
-        this.recordKill(killed, "forward");
-    }
-    /** ^Y: yank most recent kill at cursor. No-op if ring is empty. */
-    yank() {
-        if (this.killRing.length === 0)
-            return undefined;
-        const top = this.killRing[0];
-        this.insert(top);
-        this.yankIndex = 0;
-        return top;
-    }
-    /**
-     * M-y: rotate yank ring. Caller must have just yanked. Removes the
-     * previously yanked text and inserts the next entry from the ring.
-     */
-    yankPop(prevYank) {
-        if (this.killRing.length === 0)
-            return undefined;
-        this.yankIndex = (this.yankIndex + 1) % this.killRing.length;
-        if (this._cursor < prevYank.length)
-            return undefined;
-        const start = this._cursor - toCodePoints(prevYank).length;
-        this.pushUndo();
-        this.chars.splice(start, toCodePoints(prevYank).length);
-        this._cursor = start;
-        const next = this.killRing[this.yankIndex];
-        const cps = toCodePoints(next);
-        this.chars.splice(this._cursor, 0, ...cps);
-        this._cursor += cps.length;
-        return next;
-    }
-    /** Reset the kill-merge tracker. Called when a non-kill action runs. */
-    resetKillTracking() {
-        this.lastKill = "none";
-    }
-    /** Test helper / introspection. */
-    getKillRing() {
-        return this.killRing;
-    }
-    // -------------------------------------------------------------------------
-    // Undo
-    // -------------------------------------------------------------------------
-    /** Push the current state onto the undo stack. */
-    pushUndo() {
-        this.undoStack.push({ text: this.text, cursor: this._cursor });
-        if (this.undoStack.length > LineBuffer.UNDO_STACK_MAX) {
-            this.undoStack.shift();
-        }
-    }
-    /** ^_: pop the most recent snapshot. Returns true if anything happened. */
-    undo() {
-        const snap = this.undoStack.pop();
-        if (!snap)
-            return false;
-        this.chars = toCodePoints(snap.text);
-        this._cursor = this.clampCursor(snap.cursor);
-        this.lastKill = "none";
-        return true;
-    }
-    // -------------------------------------------------------------------------
-    // Internals
-    // -------------------------------------------------------------------------
-    clampCursor(c) {
-        if (c < 0)
-            return 0;
-        if (c > this.chars.length)
-            return this.chars.length;
-        return c;
-    }
-    recordKill(text, dir) {
-        if (text.length === 0)
-            return;
-        if (this.lastKill === dir && this.killRing.length > 0) {
-            // Merge with the previous kill so consecutive ^K / ^W feel like one
-            // logical kill in the yank ring.
-            this.killRing[0] =
-                dir === "forward"
-                    ? this.killRing[0] + text
-                    : text + this.killRing[0];
-        }
-        else {
-            this.killRing.unshift(text);
-            if (this.killRing.length > LineBuffer.KILL_RING_MAX) {
-                this.killRing.length = LineBuffer.KILL_RING_MAX;
-            }
-        }
-        this.lastKill = dir;
-        this.yankIndex = -1;
-    }
-}
-LineBuffer.KILL_RING_MAX = 32;
-LineBuffer.UNDO_STACK_MAX = 256;
+* Pure line buffer plus kill ring plus undo. Used by the keymap layer.
+*/
+var LineBuffer = class LineBuffer {
+	static {
+		this.KILL_RING_MAX = 32;
+	}
+	static {
+		this.UNDO_STACK_MAX = 256;
+	}
+	constructor(initial = "", cursor) {
+		this.chars = [];
+		this._cursor = 0;
+		this.killRing = [];
+		this.yankIndex = -1;
+		this.lastKill = "none";
+		this.undoStack = [];
+		this.chars = toCodePoints(initial);
+		this._cursor = cursor === void 0 ? this.chars.length : this.clampCursor(cursor);
+	}
+	get text() {
+		return this.chars.join("");
+	}
+	get cursor() {
+		return this._cursor;
+	}
+	get length() {
+		return this.chars.length;
+	}
+	snapshot() {
+		return {
+			text: this.text,
+			cursor: this._cursor
+		};
+	}
+	restore(snap) {
+		this.chars = toCodePoints(snap.text);
+		this._cursor = this.clampCursor(snap.cursor);
+		this.lastKill = "none";
+	}
+	/**
+	* Replace the entire buffer in one go. Used when navigating history or
+	* accepting a completion. Does NOT push an undo entry on its own — call
+	* `pushUndo()` first if you want to record the previous state.
+	*/
+	setText(text, cursor) {
+		this.chars = toCodePoints(text);
+		this._cursor = cursor === void 0 ? this.chars.length : this.clampCursor(cursor);
+		this.lastKill = "none";
+	}
+	moveLeft() {
+		if (this._cursor > 0) this._cursor--;
+		this.lastKill = "none";
+	}
+	moveRight() {
+		if (this._cursor < this.chars.length) this._cursor++;
+		this.lastKill = "none";
+	}
+	moveHome() {
+		this._cursor = 0;
+		this.lastKill = "none";
+	}
+	moveEnd() {
+		this._cursor = this.chars.length;
+		this.lastKill = "none";
+	}
+	/**
+	* Move left over one word. Word ≙ run of alphanumerics. Skip the
+	* non-alphanumerics immediately to the left first (matches readline's
+	* `M-b`). Pure stdlib `\w` is locale-sensitive in some runtimes; we
+	* use a `RegExp` against the actual code-point string.
+	*/
+	moveWordLeft() {
+		let i = this._cursor;
+		while (i > 0 && !isWordChar(this.chars[i - 1])) i--;
+		while (i > 0 && isWordChar(this.chars[i - 1])) i--;
+		this._cursor = i;
+		this.lastKill = "none";
+	}
+	moveWordRight() {
+		let i = this._cursor;
+		while (i < this.chars.length && !isWordChar(this.chars[i])) i++;
+		while (i < this.chars.length && isWordChar(this.chars[i])) i++;
+		this._cursor = i;
+		this.lastKill = "none";
+	}
+	/** Insert a string at the cursor (split into code points first). */
+	insert(s) {
+		if (s.length === 0) return;
+		this.pushUndo();
+		const cps = toCodePoints(s);
+		this.chars.splice(this._cursor, 0, ...cps);
+		this._cursor += cps.length;
+		this.lastKill = "none";
+	}
+	/** Backspace: delete the code point to the left of cursor. */
+	deleteLeft() {
+		if (this._cursor === 0) return;
+		this.pushUndo();
+		this.chars.splice(this._cursor - 1, 1);
+		this._cursor--;
+		this.lastKill = "none";
+	}
+	/** Delete the code point to the right of cursor. */
+	deleteRight() {
+		if (this._cursor === this.chars.length) return;
+		this.pushUndo();
+		this.chars.splice(this._cursor, 1);
+		this.lastKill = "none";
+	}
+	/** ^K: kill from cursor to end-of-line. Appends if previous kill was forward. */
+	killToEnd() {
+		if (this._cursor === this.chars.length) return;
+		this.pushUndo();
+		const killed = this.chars.slice(this._cursor).join("");
+		this.chars.length = this._cursor;
+		this.recordKill(killed, "forward");
+	}
+	/** ^U: kill from start-of-line to cursor. */
+	killToStart() {
+		if (this._cursor === 0) return;
+		this.pushUndo();
+		const killed = this.chars.slice(0, this._cursor).join("");
+		this.chars.splice(0, this._cursor);
+		this._cursor = 0;
+		this.recordKill(killed, "backward");
+	}
+	/** ^W: kill the word (backward) to the left of cursor. */
+	killWordLeft() {
+		if (this._cursor === 0) return;
+		let i = this._cursor;
+		while (i > 0 && !isWordChar(this.chars[i - 1])) i--;
+		while (i > 0 && isWordChar(this.chars[i - 1])) i--;
+		if (i === this._cursor) return;
+		this.pushUndo();
+		const killed = this.chars.slice(i, this._cursor).join("");
+		this.chars.splice(i, this._cursor - i);
+		this._cursor = i;
+		this.recordKill(killed, "backward");
+	}
+	/** M-d: kill the word (forward) starting at cursor. */
+	killWordRight() {
+		if (this._cursor === this.chars.length) return;
+		let i = this._cursor;
+		while (i < this.chars.length && !isWordChar(this.chars[i])) i++;
+		while (i < this.chars.length && isWordChar(this.chars[i])) i++;
+		if (i === this._cursor) return;
+		this.pushUndo();
+		const killed = this.chars.slice(this._cursor, i).join("");
+		this.chars.splice(this._cursor, i - this._cursor);
+		this.recordKill(killed, "forward");
+	}
+	/** ^Y: yank most recent kill at cursor. No-op if ring is empty. */
+	yank() {
+		if (this.killRing.length === 0) return void 0;
+		const top = this.killRing[0];
+		this.insert(top);
+		this.yankIndex = 0;
+		return top;
+	}
+	/**
+	* M-y: rotate yank ring. Caller must have just yanked. Removes the
+	* previously yanked text and inserts the next entry from the ring.
+	*/
+	yankPop(prevYank) {
+		if (this.killRing.length === 0) return void 0;
+		this.yankIndex = (this.yankIndex + 1) % this.killRing.length;
+		if (this._cursor < prevYank.length) return void 0;
+		const start = this._cursor - toCodePoints(prevYank).length;
+		this.pushUndo();
+		this.chars.splice(start, toCodePoints(prevYank).length);
+		this._cursor = start;
+		const next = this.killRing[this.yankIndex];
+		const cps = toCodePoints(next);
+		this.chars.splice(this._cursor, 0, ...cps);
+		this._cursor += cps.length;
+		return next;
+	}
+	/** Reset the kill-merge tracker. Called when a non-kill action runs. */
+	resetKillTracking() {
+		this.lastKill = "none";
+	}
+	/** Test helper / introspection. */
+	getKillRing() {
+		return this.killRing;
+	}
+	/** Push the current state onto the undo stack. */
+	pushUndo() {
+		this.undoStack.push({
+			text: this.text,
+			cursor: this._cursor
+		});
+		if (this.undoStack.length > LineBuffer.UNDO_STACK_MAX) this.undoStack.shift();
+	}
+	/** ^_: pop the most recent snapshot. Returns true if anything happened. */
+	undo() {
+		const snap = this.undoStack.pop();
+		if (!snap) return false;
+		this.chars = toCodePoints(snap.text);
+		this._cursor = this.clampCursor(snap.cursor);
+		this.lastKill = "none";
+		return true;
+	}
+	clampCursor(c) {
+		if (c < 0) return 0;
+		if (c > this.chars.length) return this.chars.length;
+		return c;
+	}
+	recordKill(text, dir) {
+		if (text.length === 0) return;
+		if (this.lastKill === dir && this.killRing.length > 0) this.killRing[0] = dir === "forward" ? this.killRing[0] + text : text + this.killRing[0];
+		else {
+			this.killRing.unshift(text);
+			if (this.killRing.length > LineBuffer.KILL_RING_MAX) this.killRing.length = LineBuffer.KILL_RING_MAX;
+		}
+		this.lastKill = dir;
+		this.yankIndex = -1;
+	}
+};
 /**
- * Word character classifier. Matches readline's default: ASCII alphanumeric
- * plus underscore. Non-ASCII letters are treated as word chars too so
- * "señor" moves as one word.
- */
+* Word character classifier. Matches readline's default: ASCII alphanumeric
+* plus underscore. Non-ASCII letters are treated as word chars too so
+* "señor" moves as one word.
+*/
 const isWordChar = (ch) => {
-    if (ch.length === 0)
-        return false;
-    const cp = ch.codePointAt(0) ?? 0;
-    if (cp >= 0x30 && cp <= 0x39)
-        return true; // 0-9
-    if (cp >= 0x41 && cp <= 0x5a)
-        return true; // A-Z
-    if (cp >= 0x61 && cp <= 0x7a)
-        return true; // a-z
-    if (cp === 0x5f)
-        return true; // _
-    if (cp > 0x7f) {
-        // Treat any non-ASCII printable as word-ish; cheap heuristic but
-        // sufficient for editor word motion.
-        return cp >= 0xa0;
-    }
-    return false;
+	if (ch.length === 0) return false;
+	const cp = ch.codePointAt(0) ?? 0;
+	if (cp >= 48 && cp <= 57) return true;
+	if (cp >= 65 && cp <= 90) return true;
+	if (cp >= 97 && cp <= 122) return true;
+	if (cp === 95) return true;
+	if (cp > 127) return cp >= 160;
+	return false;
 };
+//#endregion
+export { LineBuffer };