buninu 0.4.21 → 0.6.0

package/apps/jsgotty/clipboard.js

@@ -0,0 +1,148 @@
+"use strict";
+const createPowerShellClipboard = require('./clipboard-powershell.js');
+// Self-contained so the worker remains valid after bundling/minification.
+function clipboardRuntime(createPowerShellClipboard) {
+  const {spawnSync} = require('node:child_process');
+  const fs = require('node:fs');
+  const path = require('node:path');
+  const MAX_OSC52 = 1024 * 1024;
+  function which(name) {
+    if (typeof Bun !== 'undefined') return Bun.which(name);
+    const names=process.platform==='win32' && !path.extname(name)
+      ? [name,...(process.env.PATHEXT || '.EXE;.CMD;.BAT').split(';').map(ext=>name+ext)] : [name];
+    for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+      for(const candidate of names) {
+        const file=path.join(dir,candidate);
+        try {fs.accessSync(file,fs.constants.X_OK);if(fs.statSync(file).isFile())return file;} catch {}
+      }
+    }
+    return null;
+  }
+  function runSync(command, options={}) {
+    try {
+      const r=spawnSync(command[0],command.slice(1),{
+        input:options.stdin, encoding:'utf8', timeout:options.timeout ?? 2000,
+        maxBuffer:MAX_OSC52, stdio:['pipe',options.stdout ?? 'pipe','pipe'],windowsHide:true,
+      });
+      return {ok:!r.error && r.status===0,stdout:r.stdout || '',stderr:r.stderr || String(r.error || '')};
+    } catch(error) {return {ok:false,stdout:'',stderr:String(error)};}
+  }
+  function outputOrThrow(result) {
+    if (!result.ok) throw new Error(result.stderr || result.stdout || 'clipboard command failed');
+    return result.stdout;
+  }
+  function createClipboard({find=which,run=runSync,platform=process.platform}={}) {
+    const internal=new Map();
+    function candidates(register,write,text) {
+      const result=[];
+      const command=(name,args)=>{const executable=find(name);if(executable)result.push(()=>run([executable,...args],write?{stdin:text,stdout:'ignore'}:{}));};
+      // Always first, including Windows and Android. Failure does not pin a backend.
+      command('xclip',['-selection',register,...(write?[]:['-o'])]);
+      if(register==='clipboard') {
+        command(write?'termux-clipboard-set':'termux-clipboard-get',[]);
+      }
+      if(register!=='secondary')command(write?'wl-copy':'wl-paste',[...(write?[]:['--no-newline']),...(register==='primary'?['--primary']:[])]);
+      command('xsel',[`--${register}`,write?'--input':'--output']);
+      if(register==='clipboard') {
+        if(platform==='darwin')command(write?'pbcopy':'pbpaste',[]);
+        if(platform==='win32')for(const name of ['pwsh.exe','powershell.exe','pwsh','powershell']){
+          const shell=find(name);if(!shell)continue;
+          const backend=createPowerShellClipboard(shell,run,outputOrThrow);
+          result.push(()=>write?{ok:backend.write(text)}:{ok:true,stdout:backend.read()});
+        }
+      }
+      return result;
+    }
+    return {
+      read(register='clipboard') {
+        if(/^cut[0-7]$/.test(register))return internal.get(register);
+        for(const attempt of candidates(register,false))try {
+          const r=attempt();if(r.ok){internal.set(register,r.stdout);return r.stdout;}
+        }catch{}
+        return internal.get(register);
+      },
+      write(text,register='clipboard') {
+        internal.set(register,text);
+        if(/^cut[0-7]$/.test(register))return;
+        for(const attempt of candidates(register,true,text))try {if(attempt().ok)return;}catch{}
+      },
+    };
+  }
+  function parseOSC52(data) {
+    if(typeof data!=='string'||data.length>MAX_OSC52)return null;
+    const i=data.indexOf(';');if(i<0)return null;
+    const selection=data.slice(0,i),payload=data.slice(i+1);
+    if(!/^[cpqs0-7]*$/.test(selection)||selection.length>16)return null;
+    const registers=[...new Set([...(selection || 's0')].map(c=>({c:'clipboard',p:'primary',q:'secondary',s:'clipboard'}[c]||`cut${c}`)))];
+    if(payload==='?')return {selection,registers,read:true};
+    // OSC 52 specifies clearing the selection for non-base64 data.
+    const valid=/^[A-Za-z0-9+/]*={0,2}$/.test(payload) && payload.replace(/=+$/,'').length % 4 !== 1;
+    return {selection,registers,read:false,text:valid?Buffer.from(payload,'base64').toString('utf8'):''};
+  }
+  function executeOSC52(clipboard,request) {
+    if(request.read) {
+      let text;
+      for(const register of request.registers){text=clipboard.read(register);if(text!==undefined)break;}
+      const data=Buffer.from(text ?? '', 'utf8');
+      if(data.length>MAX_OSC52)return null;
+      return `\x1b]52;${request.selection};${data.toString('base64')}\x1b\\`;
+    }
+    for(const register of request.registers)clipboard.write(request.text,register);
+    return null;
+  }
+  return {createClipboard,parseOSC52,executeOSC52,MAX_OSC52};
+}
+const {createClipboard,parseOSC52,executeOSC52,MAX_OSC52}=clipboardRuntime(createPowerShellClipboard);
+module.exports={createClipboard,parseOSC52,executeOSC52,MAX_OSC52};
+
+// Run the synchronous jsmdcui-compatible backends off the server event loop.
+// Inline the helpers so compiled single-file builds need no external worker file.
+class ClipboardHost {
+  constructor(){this.pending=new Map();this.nextId=0;this.worker=null;}
+  execute(request){
+    if(this.pending.size>=32)return Promise.reject(Error('clipboard queue full'));
+    if(!this.worker){
+      const {Worker}=require('node:worker_threads');
+      const source=`const {parentPort}=require('node:worker_threads');
+const runtime=(${clipboardRuntime.toString()})(${createPowerShellClipboard.toString()});
+const clipboard=runtime.createClipboard();parentPort.on('message',({id,request})=>{
+ try{parentPort.postMessage({id,result:runtime.executeOSC52(clipboard,request)});}
+ catch(error){parentPort.postMessage({id,error:String(error)});}
+});`;
+      const worker=this.worker=new Worker(source,{eval:true});
+      const failed=error=>{
+        if(this.worker!==worker)return;
+        this.worker=null;
+        for(const job of this.pending.values())job.reject(error);
+        this.pending.clear();worker.terminate();
+      };
+      worker.on('error',failed);
+      worker.on('exit',()=>failed(Error('clipboard worker exited')));
+      worker.on('message',({id,result,error})=>{
+        const job=this.pending.get(id);if(!job)return;
+        this.pending.delete(id);error?job.reject(Error(error)):job.resolve(result);
+        if(!this.pending.size)worker.unref();
+      });
+      worker.unref();
+    }
+    return new Promise((resolve,reject)=>{
+      const id=++this.nextId;this.pending.set(id,{resolve,reject});this.worker.ref();
+      this.worker.postMessage({id,request});
+    });
+  }
+  async close(){
+    const worker=this.worker;this.worker=null;
+    for(const job of this.pending.values())job.reject(Error('clipboard closed'));
+    this.pending.clear();if(worker)await worker.terminate();
+  }
+}
+// Authorization is checked both before host access and before returning data.
+function handleOSC52(session,ws,payload,host){
+  if(!session.isWriter(ws))return;
+  const request=parseOSC52(payload);if(!request)return;
+  host.execute(request).then(reply=>{
+    if(reply && !session.closed && session.isWriter(ws))session.backend.write(Buffer.from(reply));
+  }).catch(()=>{});
+}
+module.exports.ClipboardHost=ClipboardHost;
+module.exports.handleOSC52=handleOSC52;

package/apps/jsgotty/gotty.js

@@ -12,7 +12,10 @@ const crypto = require("crypto");
 const zlib = require("zlib");
 const { constants: fsConstants } = require("fs");
 const WebSocket = require("ws");
+const { TerminalModeTracker } = require("./terminal-modes.js");
 const { WebSocketServer } = WebSocket;
+const { ClipboardHost, handleOSC52 } = require("./clipboard.js");
+const clipboardHost = new ClipboardHost();
 
 const MSG_INPUT = "1";
 const MSG_PING = "2";
@@ -34,6 +37,7 @@ const MSG_ZMODEM_MODE = "z";
 const MSG_ZMODEM_OUTPUT = "y";
 const MSG_ZMODEM_ACK = "Y";
 const MSG_KITTY_DEBUG = "K";
+const MSG_RESTORE_MODES = "m";
 const KITTY_TRACE = /^(1|true|yes|on)$/i.test(String(process.env.JSGOTTY_KITTY_DEBUG || ""));
 const WINDOWS_BRIDGE_TRACE = process.env.WINDOWS_BRIDGE_TRACE === "1";
 const WINDOWS_BRIDGE_PREFIX = Buffer.from("@@GOTTYCTL:", "ascii");
@@ -1001,7 +1005,9 @@ class CursorStateTracker {
 }
 
 class KittyGraphicsParser {
-  constructor() {
+  constructor({ binaryData = false } = {}) {
+    // Local renderers can consume bytes directly; browser clients retain base64.
+    this.binaryData = binaryData;
     this.pending = Buffer.alloc(0);
     this.transfers = new Map();
     this.images = new Map();
@@ -1220,7 +1226,7 @@ class KittyGraphicsParser {
       width: Number.parseInt(existing.control.s || "0", 10),
       height: Number.parseInt(existing.control.v || "0", 10),
       mime: existing.control.U || existing.control.mime || null,
-      data: binary.toString("base64")
+      data: this.binaryData ? binary : binary.toString("base64")
     };
 
     this.images.set(imageId, image);
@@ -1678,6 +1684,7 @@ class PtySession {
     this.supportsWindowsBridge = process.platform === "win32";
     this.cursorTracker = new CursorStateTracker();
     this.cursorTracker.setDimensions(this.columns || 80);
+    this.modeTracker = new TerminalModeTracker();
     this.kittyParser = new KittyGraphicsParser();
     this.windowsBridgeParser = this.supportsWindowsBridge ? new WindowsBridgeParser("incoming") : null;
     this.outgoingWindowsBridgeParser = this.supportsWindowsBridge ? new WindowsBridgeParser("outgoing") : null;
@@ -1757,6 +1764,7 @@ class PtySession {
         if (!this.supportsWindowsBridge) {
           const cursorBefore = this.cursorTracker.snapshot();
           this.cursorTracker.consume(filteredChunk);
+          this.modeTracker.consume(filteredChunk);
           const cursorAfter = this.cursorTracker.snapshot();
           const controls = cursorControls(filteredChunk);
           if (controls.length > 0) {
@@ -1774,6 +1782,7 @@ class PtySession {
         if (bridged.plain.length > 0) {
           const cursorBefore = this.cursorTracker.snapshot();
           this.cursorTracker.consume(bridged.plain);
+          this.modeTracker.consume(bridged.plain);
           const cursorAfter = this.cursorTracker.snapshot();
           const controls = cursorControls(bridged.plain);
           if (controls.length > 0) {
@@ -1853,6 +1862,9 @@ class PtySession {
       this.writerWs = ws;
     }
     this.sendSessionMetadata(ws, remoteAddr);
+    // Queued ahead of live output; the client applies only modes that differ,
+    // which also clears modes a program turned off while the socket was down.
+    this.send(MSG_RESTORE_MODES, JSON.stringify(this.modeTracker.snapshot()), ws);
     this.startWebSocketHandlers(ws);
     this.notifyRoles();
     return true;
@@ -2440,6 +2452,9 @@ class PtySession {
     }
 
     switch (type) {
+      case "C":
+        handleOSC52(this, ws, payload, clipboardHost);
+        break;
       case MSG_INPUT:
         if (!this.isWriter(ws) || payload.length === 0) {
           return;

package/apps/jsgotty/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "jsgotty",
-  "version": "1.1.16",
+  "version": "1.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "jsgotty",
-      "version": "1.1.16",
+      "version": "1.3.0",
       "dependencies": {
         "node-addon-api": "^7.1.1",
         "ws": "^8.18.3"

package/apps/jsgotty/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsgotty",
-  "version": "1.1.16",
+  "version": "1.3.0",
   "description": "Share your terminal as a web application: A JavaScript rewrite of GoTTY",
   "license": "MIT",
   "bin": {

package/apps/jsgotty/static/css/index.css

@@ -10,4 +10,10 @@ html, body, #terminal {
   transition: unset;
   transition-duration: 0.1s;
   transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
-}
+}
+
+/* Keep touch taps available to xterm even with a widened WebView viewport.
+   Include the viewport (a scroll container); preserve panning and pinch zoom. */
+#terminal, #terminal .xterm, #terminal .xterm-viewport, #terminal .xterm-screen {
+    touch-action: manipulation;
+}

package/apps/jsgotty/static/index.html

@@ -30,6 +30,7 @@
   <script src="./js/windows_bridge.js"></script>
   <script src="./js/zmodem.js"></script>
   <script src="./js/xterm-addon-unicode11.js"></script>
+  <script src="./js/kitty-keyboard.js"></script>
   <script src="./js/gotty.js"></script>
 
 

package/apps/jsgotty/static/js/gotty.js

@@ -12168,7 +12168,8 @@
           (t.msgSetWindowTitle = "3"),
           (t.msgSetPreferences = "4"),
           (t.msgSetReconnect = "5"),
-          (t.msgSetBufferSize = "6"));
+          (t.msgSetBufferSize = "6"),
+          (t.msgRestoreModes = "m"));
         t.WebTTY = class {
           term;
           connectionFactory;
@@ -12193,6 +12194,9 @@
             this.reconnectDeadline = 0;
             this.reconnectAttempts = 0;
             this.zmodemExpectedSeq = 0;
+            this.term.onClipboard?.(data => {
+              if (!this.disconnected) this.connection.send("C" + data);
+            });
           }
           open() {
             let e;
@@ -12330,6 +12334,9 @@
                       const e = JSON.parse(i);
                       this.term.setPreferences(e);
                       break;
+                    case t.msgRestoreModes:
+                      this.term.applySessionModes(JSON.parse(i));
+                      break;
                     case t.msgSetReconnect:
                       const r = JSON.parse(i);
                       "number" == typeof r
@@ -12540,9 +12547,33 @@
 	              })),
 	              (this.fitAddOn = new s.FitAddon()),
 	              (this.zmodemAddon = new a.ZModemAddon({
-	                toTerminal: (e) => this.term.write(e),
+	                toTerminal: (e) => this.writeTerminal(e),
 	                toServer: (e) => this.sendInput(e),
 	              })),
+              (this.kittyKeyboard = new globalThis.GoTTYKittyKeyboard.KittyKeyboard(this.term, {
+                android: /Android/i.test(navigator.userAgent),
+              })),
+              this.term.parser.registerOscHandler(52, data => {
+                if (!this.disconnected && data.length <= 1048576) this.clipboardHandler?.(data);
+                return true;
+              }),
+              this.term.parser.registerOscHandler(777, data => {
+                const match = /^jsgotty-modes;([a-f0-9]{32})$/.exec(data);
+                if (!match) {
+                  const restore = /^jsgotty-kitty-v1;(normal|alternate);(\d{1,2});(\d{1,2}(?:,\d{1,2})*)?$/.exec(data);
+                  if (!restore) return false;
+                  const flags = +restore[2], stack = restore[3] ? restore[3].split(',').map(Number) : [];
+                  if (flags > 31 || stack.length > 32 || stack.some(n => n > 31)) return true;
+                  this.kittyKeyboard.states[restore[1]] = {flags: flags & 11, stack: stack.map(n => n & 11)};
+                  return true;
+                }
+                this.term.input("\x1b]777;jsgotty-modes;" + match[1] + ";" +
+                  btoa(JSON.stringify({...this.sessionModes(), kittyRestore: 1})) + "\x07", false);
+                return true;
+              }),
+              this.term.attachCustomKeyEventHandler((event) =>
+                this.kittyKeyboard.handle(event) && this.handleAndroidAltKey(event),
+              ),
 	              this.setPreferences(t),
 	              (() => {
 	                try {
@@ -12594,12 +12625,73 @@
                     ));
               }),
               this.term.open(e),
+              this.kittyKeyboard.attach(this.term.textarea),
+              this.term.textarea?.addEventListener("blur", () => {
+                this.androidAltDownKeys?.clear();
+              }),
               this.term.focus(),
               this.resizeListener(),
               window.addEventListener("resize", () => {
                 this.resizeListener();
               }));
           }
+          // Android can translate physical Alt shortcuts into accent dead keys.
+          // Resolve printable physical keys before xterm's composition handling.
+          handleAndroidAltKey(event) {
+            if (!/Android/i.test(navigator.userAgent)) return true;
+            let code = event.code;
+            // Some Android IMEs omit code and swallow the dead-key keydown,
+            // but still deliver keyup with a usable legacy keyCode.
+            if (!code) {
+              if (event.keyCode >= 65 && event.keyCode <= 90)
+                code = "Key" + String.fromCharCode(event.keyCode);
+              else if (event.keyCode >= 48 && event.keyCode <= 57)
+                code = "Digit" + String.fromCharCode(event.keyCode);
+              else code = {
+                32: "Space", 186: "Semicolon", 187: "Equal", 188: "Comma",
+                189: "Minus", 190: "Period", 191: "Slash", 192: "Backquote",
+                219: "BracketLeft", 220: "Backslash", 221: "BracketRight", 222: "Quote",
+              }[event.keyCode];
+            }
+            this.androidAltDownKeys ??= new Set();
+            const alreadySent = event.type === "keyup" && this.androidAltDownKeys.delete(code);
+            if (
+              !["keydown", "keypress", "keyup"].includes(event.type) ||
+              !event.altKey || event.ctrlKey || event.metaKey ||
+              event.isComposing || event.getModifierState?.("AltGraph") ||
+              (event.type === "keyup" && event.key !== "Dead")
+            ) return true;
+
+            let character;
+            if (/^Key[A-Z]$/.test(code)) {
+              const letter = code.slice(3);
+              character = event.shiftKey ? letter : letter.toLowerCase();
+            } else if (/^Digit[0-9]$/.test(code)) {
+              const digit = code.slice(5);
+              character = event.shiftKey ? ")!@#$%^&*("[Number(digit)] : digit;
+            } else {
+              const punctuation = {
+                Backquote: ["`", "~"], Minus: ["-", "_"], Equal: ["=", "+"],
+                BracketLeft: ["[", "{"], BracketRight: ["]", "}"],
+                Backslash: ["\\", "|"], Semicolon: [";", ":"], Quote: ["'", '"'],
+                Comma: [",", "<"], Period: [".", ">"], Slash: ["/", "?"],
+                Space: [" ", " "],
+              };
+              character = Object.hasOwn(punctuation, code)
+                ? punctuation[code][event.shiftKey ? 1 : 0]
+                : undefined;
+            }
+            if (character === undefined) return true;
+            event.preventDefault();
+            event.stopPropagation();
+            if (event.type === "keydown") {
+              this.androidAltDownKeys.add(code);
+              this.term.input("\x1b" + character, true);
+            } else if (event.type === "keyup" && !alreadySent) {
+              this.term.input("\x1b" + character, true);
+            }
+            return false;
+          }
           info() {
             return { columns: this.term.cols, rows: this.term.rows };
           }
@@ -12609,7 +12701,73 @@
           getMessage() {
             return this.message;
           }
+          enqueueTerminal(task) {
+            this.terminalTasks ||= [];
+            this.terminalTasks.push(task);
+            if (this.terminalBusy) return;
+            this.terminalBusy = true;
+            const next = () => {
+              const task = this.terminalTasks.shift();
+              if (!task) { this.terminalBusy = false; return; }
+              task(next);
+            };
+            next();
+          }
+          writeTerminal(data) {
+            this.enqueueTerminal(done => this.term.write(data, done));
+          }
+          onClipboard(handler) {
+            this.clipboardHandler = handler;
+          }
+          sessionModes() {
+            const core = this.term._core;
+            return {dec: {...core.coreService.decPrivateModes},
+              mouse: core.coreMouseService.activeProtocol,
+              encoding: core.coreMouseService.activeEncoding,
+              cursorHidden: !!core.coreService.isCursorHidden,
+              alternate: this.term.buffer.active.type === "alternate",
+              kitty: JSON.parse(JSON.stringify(this.kittyKeyboard.states))};
+          }
+          applySessionModes(state) {
+            this.enqueueTerminal(done => this.term.write("", () => this.restoreSessionModes(state, done)));
+          }
+          restoreSessionModes(state, done) {
+            if (!state || !state.dec) { done(); return; }
+            const core = this.term._core;
+            const dec = core.coreService.decPrivateModes;
+            const mouse = core.coreMouseService;
+            // A socket-only reconnect keeps xterm's modes, so send only differences:
+            // DECOM homes the cursor and 1049 overwrites the saved cursor.
+            let sequence = "";
+            const alternate = this.term.buffer.active.type === "alternate";
+            if (!!state.alternate !== alternate) sequence += `\x1b[?1049${state.alternate ? "h" : "l"}`;
+            const flags = {1:"applicationCursorKeys", 6:"origin", 7:"wraparound", 45:"reverseWraparound",
+              66:"applicationKeypad", 1004:"sendFocus", 2004:"bracketedPasteMode"};
+            for (const [mode, name] of Object.entries(flags))
+              if (!!state.dec[name] !== !!dec[name]) sequence += `\x1b[?${mode}${state.dec[name] ? "h" : "l"}`;
+            if (!!state.cursorHidden !== !!core.coreService.isCursorHidden)
+              sequence += `\x1b[?25${state.cursorHidden ? "l" : "h"}`;
+            if (state.mouse !== mouse.activeProtocol) {
+              const modes = {X10:9, VT200:1000, DRAG:1002, ANY:1003};
+              sequence += modes[state.mouse] ? `\x1b[?${modes[state.mouse]}h` : "\x1b[?1000l";
+            }
+            if (state.encoding !== mouse.activeEncoding) {
+              const modes = {SGR:1006, SGR_PIXELS:1016};
+              sequence += modes[state.encoding] ? `\x1b[?${modes[state.encoding]}h` : "\x1b[?1006l";
+            }
+            const complete = () => {
+            // Assigned rather than replayed so the push stack never doubles; the server
+            // keeps every flag, so mask to the ones kitty-keyboard.js implements.
+            const supported = (s) => ({flags: s.flags & 11, stack: s.stack.map((f) => f & 11)});
+            if (state.kitty?.normal && state.kitty?.alternate)
+              this.kittyKeyboard.states = {normal: supported(state.kitty.normal), alternate: supported(state.kitty.alternate)};
+              done();
+            };
+            if (sequence) this.term.write(sequence, complete);
+            else complete();
+          }
           setDisconnected(e) {
+            if (e) this.kittyKeyboard.clearHeld(false);
             this.disconnected = !!e;
           }
           setReconnectAction(e) {
@@ -12721,9 +12879,12 @@
             this.term.blur();
           }
           reset() {
+            // Reconnecting the transport does not reset the running PTY's modes.
+            this.kittyKeyboard.clearHeld(false);
             (this.removeMessage(), this.term.clear());
           }
           close() {
+            this.kittyKeyboard.dispose();
             (window.removeEventListener("resize", this.resizeListener),
               this.term.dispose());
           }
@@ -26746,39 +26907,32 @@
                         case 37:
                           if (e.metaKey) break;
                           a
-                            ? ((o.key = r.C0.ESC + "[1;" + (a + 1) + "D"),
-                              o.key === r.C0.ESC + "[1;3D" &&
-                                (o.key = r.C0.ESC + (i ? "b" : "[1;5D")))
+                            ? (o.key = r.C0.ESC + "[1;" + (a + 1) + "D")
                             : (o.key = t ? r.C0.ESC + "OD" : r.C0.ESC + "[D");
                           break;
                         case 39:
                           if (e.metaKey) break;
                           a
-                            ? ((o.key = r.C0.ESC + "[1;" + (a + 1) + "C"),
-                              o.key === r.C0.ESC + "[1;3C" &&
-                                (o.key = r.C0.ESC + (i ? "f" : "[1;5C")))
+                            ? (o.key = r.C0.ESC + "[1;" + (a + 1) + "C")
                             : (o.key = t ? r.C0.ESC + "OC" : r.C0.ESC + "[C");
                           break;
                         case 38:
                           if (e.metaKey) break;
                           a
-                            ? ((o.key = r.C0.ESC + "[1;" + (a + 1) + "A"),
-                              i ||
-                                o.key !== r.C0.ESC + "[1;3A" ||
-                                (o.key = r.C0.ESC + "[1;5A"))
+                            ? (o.key = r.C0.ESC + "[1;" + (a + 1) + "A")
                             : (o.key = t ? r.C0.ESC + "OA" : r.C0.ESC + "[A");
                           break;
                         case 40:
                           if (e.metaKey) break;
                           a
-                            ? ((o.key = r.C0.ESC + "[1;" + (a + 1) + "B"),
-                              i ||
-                                o.key !== r.C0.ESC + "[1;3B" ||
-                                (o.key = r.C0.ESC + "[1;5B"))
+                            ? (o.key = r.C0.ESC + "[1;" + (a + 1) + "B")
                             : (o.key = t ? r.C0.ESC + "OB" : r.C0.ESC + "[B");
                           break;
                         case 45:
-                          e.shiftKey || e.ctrlKey || (o.key = r.C0.ESC + "[2~");
+                          e.shiftKey || e.ctrlKey ||
+                            (o.key = e.altKey
+                              ? r.C0.ESC + "[2;" + (a + 1) + "~"
+                              : r.C0.ESC + "[2~");
                           break;
                         case 46:
                           o.key = a
@@ -26802,14 +26956,14 @@
                         case 33:
                           e.shiftKey
                             ? (o.type = 2)
-                            : e.ctrlKey
+                            : e.ctrlKey || e.altKey
                               ? (o.key = r.C0.ESC + "[5;" + (a + 1) + "~")
                               : (o.key = r.C0.ESC + "[5~");
                           break;
                         case 34:
                           e.shiftKey
                             ? (o.type = 3)
-                            : e.ctrlKey
+                            : e.ctrlKey || e.altKey
                               ? (o.key = r.C0.ESC + "[6;" + (a + 1) + "~")
                               : (o.key = r.C0.ESC + "[6~");
                           break;
@@ -26927,6 +27081,8 @@
                                     ))
                                   : 56 === e.keyCode
                                     ? (o.key = r.C0.DEL)
+                                    : "/" === e.key
+                                      ? (o.key = r.C0.US)
                                     : 219 === e.keyCode
                                       ? (o.key = r.C0.ESC)
                                       : 220 === e.keyCode