buninu-linux 0.14.57 → 0.16.59

package/initramfs/buninu/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/initramfs/buninu/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());
           }
@@ -15836,8 +15997,15 @@
                                 !1 === e._customWheelEventHandler(t)
                               )
                                 return !1;
-                              if (0 === e.viewport.getLinesScrolled(t))
-                                return !1;
+                              // Preserve both axes of diagonal wheel/touch gestures.
+                              // CoreMouseService already encodes wheel actions 2/3 as 66/67.
+                              if (t.deltaX) e.coreMouseService.triggerMouseEvent({
+                                col: i.col, row: i.row, x: i.x, y: i.y,
+                                button: 4, action: t.deltaX < 0 ? 2 : 3,
+                                ctrl: t.ctrlKey, alt: t.altKey, shift: t.shiftKey,
+                              });
+                              if (0 === e.viewport.getLinesScrolled(t, true))
+                                return !!t.deltaX;
                               ((s = t.deltaY < 0 ? 0 : 1), (r = 4));
                               break;
                             default:
@@ -16811,8 +16979,9 @@
                         }
                         return { bufferElements: s, cursorElement: i };
                       }
-                      getLinesScrolled(e) {
-                        if (0 === e.deltaY || e.shiftKey) return 0;
+                      getLinesScrolled(e, mouseReporting = false) {
+                        // Shift belongs to the remote application while mouse reporting is active.
+                        if (0 === e.deltaY || (e.shiftKey && !mouseReporting)) return 0;
                         let t = this._applyScrollModifier(e.deltaY, e);
                         return (
                           e.deltaMode === WheelEvent.DOM_DELTA_PIXEL
@@ -26746,39 +26915,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 +26964,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 +27089,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

package/initramfs/buninu/apps/jsgotty/static/js/kitty-keyboard.js

@@ -0,0 +1,193 @@
+// Kitty keyboard transport for the shipped xterm wrapper (no build step).
+// Spec: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+(function (root) {
+  'use strict';
+  // Supported progressive enhancements: disambiguation, event types, all keys.
+  // Do not advertise alternate-layout/text reporting until those are implemented.
+  const SUPPORTED = 1 | 2 | 8;
+  const functional = {
+    Escape:[27,'u'], Enter:[13,'u'], Tab:[9,'u'], Backspace:[127,'u'],
+    Insert:[2,'~'], Delete:[3,'~'], ArrowLeft:[1,'D'], ArrowRight:[1,'C'],
+    ArrowUp:[1,'A'], ArrowDown:[1,'B'], PageUp:[5,'~'], PageDown:[6,'~'],
+    Home:[1,'H'], End:[1,'F'], CapsLock:[57358,'u'], ScrollLock:[57359,'u'],
+    NumLock:[57360,'u'], PrintScreen:[57361,'u'], Pause:[57362,'u'], ContextMenu:[57363,'u'],
+    MediaPlay:[57428,'u'], MediaPause:[57429,'u'], MediaPlayPause:[57430,'u'],
+    MediaStop:[57432,'u'], MediaFastForward:[57433,'u'], MediaRewind:[57434,'u'],
+    MediaTrackNext:[57435,'u'], MediaTrackPrevious:[57436,'u'], MediaRecord:[57437,'u'],
+    AudioVolumeDown:[57438,'u'], AudioVolumeUp:[57439,'u'], AudioVolumeMute:[57440,'u'],
+  };
+  [11,12,13,14,15,17,18,19,20,21,23,24].forEach((n,i) => functional['F'+(i+1)] = [n,'~']);
+  for (let i=13;i<=35;i++) functional['F'+i] = [57376+i-13,'u'];
+  const punctuation = {
+    Backquote:['`','~'], Minus:['-','_'], Equal:['=','+'], BracketLeft:['[','{'],
+    BracketRight:[']','}'], Backslash:['\\','|'], Semicolon:[';',':'], Quote:["'",'"'],
+    Comma:[',','<'], Period:['.','>'], Slash:['/','?'], Space:[' ',' '],
+  };
+  const modifiers = {Shift:[1,57441], Control:[4,57442], Alt:[2,57443], Meta:[8,57444],
+    OS:[8,57444], Super:[8,57444], Hyper:[16,57445], AltGraph:[0,57453]};
+  const has = (object,key) => Object.prototype.hasOwnProperty.call(object,key);
+  const lock = (e,name) => Boolean(e.getModifierState?.(name));
+  function physicalCode(e) {
+    if (e.code && e.code !== 'Unidentified') return e.code;
+    if (e.keyCode>=65 && e.keyCode<=90) return 'Key'+String.fromCharCode(e.keyCode);
+    if (e.keyCode>=48 && e.keyCode<=57) return 'Digit'+String.fromCharCode(e.keyCode);
+    return ({32:'Space',186:'Semicolon',187:'Equal',188:'Comma',189:'Minus',190:'Period',
+      191:'Slash',192:'Backquote',219:'BracketLeft',220:'Backslash',221:'BracketRight',222:'Quote'})[e.keyCode] || '';
+  }
+  function baseCharacter(e, android) {
+    const code=physicalCode(e);
+    // Android's Alt accent conversion must not turn an E/I/N/U shortcut into a dead key.
+    const recover=android && e.altKey && !lock(e,'AltGraph');
+    if (recover || ([...e.key || ''].length===1 && e.key.codePointAt(0)<32)) {
+      if (/^Key[A-Z]$/.test(code)) return code.slice(3).toLowerCase();
+      if (/^Digit[0-9]$/.test(code)) return code.slice(5);
+      if (has(punctuation,code)) return punctuation[code][0];
+    }
+    if ([...e.key || ''].length!==1) return null;
+    if (e.shiftKey) {
+      if (has(punctuation,code) && punctuation[code][1]===e.key) return punctuation[code][0];
+      if (/^Digit[0-9]$/.test(code) && ')!@#$%^&*('[Number(code.slice(5))]===e.key) return code.slice(5);
+    }
+    const lower=e.key.toLowerCase();
+    return [...lower].length===1 ? lower : e.key;
+  }
+  function keyDefinition(e, flags, android) {
+    if (has(modifiers,e.key)) {
+      const [bit,left]=modifiers[e.key];
+      const right=e.location===2 || /Right$/.test(e.code || '');
+      return {number:left+(right && e.key!=='AltGraph'?6:0),suffix:'u',modifier:bit};
+    }
+    if ((flags & 9) && (e.location===3 || /^Numpad/.test(e.code || ''))) {
+      const numpad={NumpadDecimal:57409,NumpadDivide:57410,NumpadMultiply:57411,
+        NumpadSubtract:57412,NumpadAdd:57413,NumpadEnter:57414,NumpadEqual:57415,
+        NumpadComma:57416};
+      const nav={ArrowLeft:57417,ArrowRight:57418,ArrowUp:57419,ArrowDown:57420,
+        PageUp:57421,PageDown:57422,Home:57423,End:57424,Insert:57425,Delete:57426,Clear:57427};
+      const number=has(nav,e.key)?nav[e.key]:/^Numpad[0-9]$/.test(e.code || '')
+        ?57399+Number(e.code.slice(6)):numpad[e.code];
+      if (number) return {number,suffix:'u'};
+    }
+    if (has(functional,e.key)) {
+      const [number,suffix]=functional[e.key];
+      return {number,suffix,recovery:['Enter','Tab','Backspace'].includes(e.key)};
+    }
+    const ch=baseCharacter(e,android);
+    return ch===null?null:{number:ch.codePointAt(0),suffix:'u',text:true};
+  }
+  class KittyKeyboard {
+    constructor(term, {android=false}={}) {
+      this.term=term; this.android=android; this.disposables=[];
+      this.metaKeys=new Set(); this.down=new Map(); this.suppressed=new Set(); this.reset();
+      const register=(prefix,fn) => this.disposables.push(term.parser.registerCsiHandler({prefix,final:'u'},p=>{fn(p);return true;}));
+      const value=(p,i,fallback=0) => Number.isInteger(p[i])?p[i]:fallback;
+      register('?',()=>term.input(`\x1b[?${this.flags}u`,false));
+      register('>',p=>{const s=this.state;s.stack.push(s.flags);if(s.stack.length>32)s.stack.shift();s.flags=value(p,0)&SUPPORTED;});
+      register('<',p=>{const s=this.state;let count=Math.min(value(p,0)||1,33);while(count--)s.flags=s.stack.pop()??0;});
+      register('=',p=>{const s=this.state,f=value(p,0)&SUPPORTED,m=value(p,1)||1;if(m===1)s.flags=f;else if(m===2)s.flags|=f;else if(m===3)s.flags&=~f;});
+      this.disposables.push(term.parser.registerEscHandler({final:'c'},()=>{this.reset();return false;}));
+      this.disposables.push(term.parser.registerCsiHandler({intermediates:'!',final:'p'},()=>{this.reset();return false;}));
+    }
+    get state() { return this.states[this.term.buffer.active.type==='alternate'?'alternate':'normal']; }
+    get flags() { return this.state.flags; }
+    reset() {
+      this.states={normal:{flags:0,stack:[]},alternate:{flags:0,stack:[]}};
+      this.clearHeld(false);
+    }
+    clearHeld(report=true) {
+      // Release keys reported to the client before losing focus, avoiding stuck remote keys.
+      if (report && (this.flags & 2)) for (const key of this.down.values()) {
+        if(key.reported) this.term.input(this.sequence(key.def,0,3),true);
+      }
+      this.metaKeys.clear();this.down.clear();this.suppressed.clear();this.suppressKeypress=false;
+    }
+    attach(element) {
+      const doc=element.ownerDocument, win=doc.defaultView;
+      const blur=()=>this.clearHeld();
+      const visibility=()=>{if(doc.hidden)this.clearHeld();};
+      element.addEventListener('blur',blur);win.addEventListener('blur',blur);
+      doc.addEventListener('visibilitychange',visibility);
+      this.disposables.push({dispose:()=>{element.removeEventListener('blur',blur);win.removeEventListener('blur',blur);doc.removeEventListener('visibilitychange',visibility);}});
+    }
+    dispose() {this.clearHeld(false);for(const d of this.disposables)d.dispose();}
+    sequence(def,bits,type) {
+      const event=(this.flags&2) && type!==1?':'+type:'';
+      const mods=bits+1;
+      if(def.suffix!=='u' && mods===1 && !event)
+        return '\x1b['+(def.number===1?'':def.number)+def.suffix;
+      return `\x1b[${def.number}${mods!==1||event?';'+mods+event:''}${def.suffix}`;
+    }
+    handle(event) {
+      if (!['keydown','keyup','keypress'].includes(event.type)) return true;
+      const identity=physicalCode(event)||event.key;
+      const metaKey=['Meta','OS','Super'].includes(event.key);
+      if(this.android && metaKey) {
+        if(event.type==='keydown')this.metaKeys.add(event.code||String(event.location||0));
+        if(event.type==='keyup')this.metaKeys.delete(event.code||String(event.location||0));
+      }
+      // Patch only this terminal's Android event, preserving the native DOM event.
+      if(this.android && this.metaKeys.size && !event.metaKey) {
+        const original=event.getModifierState?.bind(event);
+        Object.defineProperties(event,{
+          metaKey:{configurable:true,value:true},
+          getModifierState:{configurable:true,value:name=>name==='Meta'||Boolean(original?.(name))},
+        });
+      }
+      if(!this.flags || this.term.options.disableStdin) return true;
+      const consume=()=>{event.preventDefault();event.stopPropagation();return false;};
+      if(event.type==='keypress')return this.suppressKeypress?consume():true;
+      let previous=this.down.get(identity);
+      if(event.type==='keyup') {
+        // Some Android IMEs emit only the release of an Alt dead key. Recover
+        // that chord here too, never falling back to legacy ESC text in Kitty mode.
+        if(!previous && this.android && event.altKey && event.key==='Dead' &&
+           !event.isComposing && !lock(event,'AltGraph') && (this.flags&9)) {
+          const def=keyDefinition(event,this.flags,this.android);
+          if(def) {
+            this.term.input(this.sequence(def,this.bits(event),1),true);
+            previous={def,reported:true};this.suppressed.add(identity);
+          }
+        }
+        this.down.delete(identity);
+        const suppressed=this.suppressed.delete(identity);
+        this.suppressKeypress=false;
+        if(previous?.reported && (this.flags&2)) {
+          let bits=this.bits(event);
+          if(previous.def.modifier && ![...this.down.values()].some(k=>k.def.modifier===previous.def.modifier)) bits &= ~previous.def.modifier;
+          if(metaKey && this.metaKeys.size) bits|=8;
+          this.term.input(this.sequence(previous.def,bits,3),true);
+        }
+        return suppressed?consume():true;
+      }
+      this.suppressKeypress=false;
+      if(event.isComposing || event.keyCode===229 && event.key==='Unidentified')return true;
+      if(event.key==='Dead' && !(this.android && event.altKey && !lock(event,'AltGraph')))return true;
+      const def=keyDefinition(event,this.flags,this.android);
+      if(!def)return true;
+      let bits=this.bits(event);
+      if(def.modifier!==undefined) {
+        if(!(this.flags&8))return true;
+        bits|=def.modifier;
+      }
+      const all=Boolean(this.flags&8);
+      // Enter/Tab/Backspace remain recovery keys unless modified or report-all is requested.
+      if(!all && def.recovery && !(bits&~192))return true;
+      const shortcut=Boolean(bits&62);
+      if(def.text && !all && !(this.flags&1 && shortcut))return true;
+      // With only event reporting requested, leave legacy printable shortcuts untouched.
+      if(def.text && !all && !(this.flags&1))return true;
+      const type=event.repeat?2:1;
+      this.down.set(identity,{def,reported:!(def.recovery && !all)});this.suppressed.add(identity);this.suppressKeypress=true;
+      this.term.input(this.sequence(def,bits,type),true);
+      return consume();
+    }
+    bits(e) {
+      const altgr=lock(e,'AltGraph');
+      return (e.shiftKey?1:0)|(!altgr&&e.altKey?2:0)|(!altgr&&e.ctrlKey?4:0)|
+        (e.metaKey || this.android&&this.metaKeys.size?8:0)|
+        (lock(e,'Hyper')?16:0)|(lock(e,'CapsLock')?64:0)|(lock(e,'NumLock')?128:0);
+    }
+  }
+  const api={KittyKeyboard,SUPPORTED};
+  if(typeof module==='object' && module.exports)module.exports=api;
+  else root.GoTTYKittyKeyboard=api;
+})(globalThis);