@neuroplastio/xterm-addon-hotty 0.1.0-next.5 → 0.1.0-next.7

package/README.md

@@ -114,10 +114,13 @@ runs programs for whoever connects.
   selection works as usual. A right click leaves focus where the browser
   put it, so the context menu's Copy copies the surface's selection.
 - **A text field's keys** (SPEC §10.2, §10.4) are the program's keymap.
-  Each key goes through xterm.js's keyboard handling, with what it would
-  send the program kept back, and is named from that, so a field sees the
-  key the program would read, in the encoding the program enabled. The
-  field's keymap (the default, then each `data-keys` from the root to the
+  A key that types no text (not a character, or a character with Control
+  or Meta) is offered first as pressed, named from the DOM's event, before
+  xterm.js translates it: on a Mac, Option+Left is Alt+ArrowLeft, not the
+  ESC b the program would read. Otherwise the key goes through xterm.js's
+  keyboard handling, with what it would send the program kept back, and
+  is named from that, so a field sees the key the program would read, in
+  the encoding the program enabled. The field's keymap (the default, then each `data-keys` from the root to the
   field) decides: an action, which the addon does itself on the field's
   text with the editing commands, so the browser sends `input` and
   `change` as for typing; a character, which the browser types; or the

package/dist/hotty-xterm.js

@@ -898,6 +898,7 @@ var ACTIONS = /* @__PURE__ */ new Set([
   "page-down",
   "input-start",
   "input-end",
+  "select-all",
   "newline",
   "submit",
   "program",
@@ -913,7 +914,21 @@ var ACTIONS = /* @__PURE__ */ new Set([
   "scroll-end"
 ]);
 var SCROLL_ACTIONS = new Set([...ACTIONS].filter((a) => a.startsWith("scroll-")));
-var MULTILINE_ACTIONS = /* @__PURE__ */ new Set(["line-previous", "line-next", "page-up", "page-down", "input-start", "input-end", "newline"]);
+var MULTILINE_ACTIONS = /* @__PURE__ */ new Set(["line-previous", "line-next", "page-up", "page-down", "newline"]);
+var MOVES = /* @__PURE__ */ new Set([
+  "char-backward",
+  "char-forward",
+  "word-backward",
+  "word-forward",
+  "line-start",
+  "line-end",
+  "line-previous",
+  "line-next",
+  "page-up",
+  "page-down",
+  "input-start",
+  "input-end"
+]);
 var ROW_ACTIONS = /* @__PURE__ */ new Set(["line-previous", "line-next", "page-up", "page-down"]);
 var BACKWARD = /* @__PURE__ */ new Set(["char-backward", "word-backward", "line-start", "line-previous", "page-up", "input-start"]);
 var INSERT = "insert";
@@ -921,7 +936,7 @@ var TERMINAL_KEYS = [
   "ArrowLeft=char-backward Control+b=char-backward ArrowRight=char-forward Control+f=char-forward",
   "Alt+ArrowLeft=word-backward Control+ArrowLeft=word-backward Alt+b=word-backward",
   "Alt+ArrowRight=word-forward Control+ArrowRight=word-forward Alt+f=word-forward",
-  "Home=line-start Control+a=line-start End=line-end Control+e=line-end",
+  "Home=line-start End=line-end Control+e=line-end",
   "Backspace=delete-char-backward Control+h=delete-char-backward",
   "Delete=delete-char-forward Control+d=delete-char-forward",
   "Alt+Backspace=delete-word-backward Control+w=delete-word-backward Control+Backspace=delete-word-backward",
@@ -930,6 +945,7 @@ var TERMINAL_KEYS = [
   "ArrowUp=line-previous Control+p=line-previous ArrowDown=line-next Control+n=line-next",
   "PageUp=page-up PageDown=page-down",
   "Alt+<=input-start Control+Home=input-start Alt+>=input-end Control+End=input-end",
+  "Control+a=select-all",
   "Control+m=newline"
 ].join(" ");
 var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
@@ -1181,6 +1197,15 @@ var Keymap = class {
     if (isChar(value) && !mods.some((m) => m !== "Shift")) return INSERT;
     return null;
   }
+  /** Whether the field selects with a key (SPEC §10.2, *Shift selects*):
+   * it looks up a move, and the key's name has Shift. The field then moves
+   * its caret and keeps the selection's anchor. */
+  selects(name) {
+    const k = parseKey(name);
+    if (k === null) return false;
+    const a = this.lookup(k);
+    return a !== null && MOVES.has(a) && splitKey(k)[0].includes("Shift");
+  }
 };
 function* bindingsOf(value) {
   for (const b of value.split(/[ \t\n\f\r]+/)) {
@@ -1207,14 +1232,31 @@ function resolve(multiline, ...values) {
   for (const [k, a] of [
     ["ArrowLeft", "char-backward"],
     ["ArrowRight", "char-forward"],
+    ["Control+ArrowLeft", "word-backward"],
+    ["Control+ArrowRight", "word-forward"],
+    ["Alt+ArrowLeft", "word-backward"],
+    ["Alt+ArrowRight", "word-forward"],
     ["Home", "line-start"],
     ["End", "line-end"],
+    ["Control+Home", "input-start"],
+    ["Control+End", "input-end"],
     ["Backspace", "delete-char-backward"],
     ["Delete", "delete-char-forward"],
+    ["Control+Backspace", "delete-word-backward"],
+    ["Control+Delete", "delete-word-forward"],
+    ["Alt+Backspace", "delete-word-backward"],
+    ["Alt+Delete", "delete-word-forward"],
     ["ArrowUp", "line-previous"],
     ["ArrowDown", "line-next"],
     ["PageUp", "page-up"],
     ["PageDown", "page-down"],
+    ["Control+a", "select-all"],
+    ["Meta+ArrowLeft", "line-start"],
+    ["Meta+ArrowRight", "line-end"],
+    ["Meta+ArrowUp", "input-start"],
+    ["Meta+ArrowDown", "input-end"],
+    ["Meta+Backspace", "delete-to-line-start"],
+    ["Meta+a", "select-all"],
     ["Enter", multiline ? "newline" : "submit"]
   ])
     m.bind(k, a);
@@ -1241,10 +1283,16 @@ function wordForward(t, p) {
   while (p < t.chars.length && !isSpace(t.chars[p])) p++;
   return p;
 }
-function plan(t, action, rows, goal = null) {
+function plan(t, action, rows, goal = null, extend = false) {
   if (MULTILINE_ACTIONS.has(action) && !t.multiline) return { kind: "none" };
   const n = t.chars.length;
   const selected = t.start < t.end;
+  if (action === "select-all") return { kind: "move", anchor: 0, to: n };
+  if (extend && MOVES.has(action)) {
+    const anchor = t.caret === t.start ? t.end : t.start;
+    const moved = plan({ ...t, start: t.caret, end: t.caret }, action, rows, goal);
+    return moved.kind === "move" ? { ...moved, anchor } : moved;
+  }
   if (action.startsWith("delete-")) {
     if (selected) return { kind: "replace", from: t.start, to: t.end, text: "" };
     const p2 = t.start;
@@ -2005,7 +2053,10 @@ var Surface = class {
     return el === this.masked ? (this.resolver.get(el, "type") ?? "").toLowerCase() : el.type;
   }
   /**
-   * A key in a text field. It is named as the program would read it: from
+   * A key in a text field, offered at most twice (SPEC §10.4). A key that
+   * types no text is offered first as pressed, named from the DOM's event,
+   * before xterm.js translates it (on a Mac, Option+ArrowLeft is ESC b to
+   * the program). Otherwise it is named as the program would read it: from
    * what xterm.js would send the program for it, in the encoding the
    * program enabled, read as SPEC §10.4 says. The field's keymap (the
    * default, then each `data-keys` from the root to the field) says what
@@ -2014,10 +2065,13 @@ var Surface = class {
    */
   fieldKey(e, el, multiline) {
     if (this.host.browserKey(e)) return;
-    const data = this.host.encodeKey(e);
-    const keys = data === null ? [{ key: domKeyName(e), data: "" }] : inputKeys(data);
     const keymap = this.keymapOf(el, multiline);
+    const pressed = typesNoText(e) ? domKeyName(e) : null;
+    const first = pressed !== null && keymap.lookup(pressed) !== null;
+    const data = first ? "" : this.host.encodeKey(e);
+    const keys = first ? [{ key: pressed, data: "" }] : data === null ? [{ key: domKeyName(e), data: "" }] : inputKeys(data);
     const uses = keys.map((k) => k.key === null ? null : keymap.lookup(k.key));
+    const extend = keys.map((k) => k.key !== null && keymap.selects(k.key));
     if (uses.every((u) => u === null)) {
       const program = keys.some((k) => k.key !== null && keymap.program(k.key));
       if (!program && this.axes && this.scrollKey(e)) return;
@@ -2046,7 +2100,7 @@ var Surface = class {
       } else if (use === "submit") {
         this.goal = null;
         submitFrom(el);
-      } else this.edit(el, multiline, { kind: "action", action: use });
+      } else this.edit(el, multiline, { kind: "action", action: use, extend: extend[i] });
     });
   }
   /** A field's keymap (SPEC §10.2): the default, then the `data-keys` of
@@ -2074,6 +2128,7 @@ var Surface = class {
     };
     const start = index(el.selectionStart ?? el.value.length);
     const end = index(el.selectionEnd ?? el.value.length);
+    const caret = el.selectionDirection === "backward" ? start : end;
     if (what.kind === "type") {
       this.goal = null;
       this.replace(el, at[start], at[end], what.text);
@@ -2081,14 +2136,16 @@ var Surface = class {
     }
     const action = what.action;
     const password = el.localName === "input" && this.inputType(el) === "password";
-    const text2 = { chars: cl, start, end, multiline, password };
+    const text2 = { chars: cl, start, end, caret, multiline, password };
     const g = this.goal;
-    const goal = ROW_ACTIONS.has(action) && g && g.el === el && start === end && g.caret === start ? g.x : null;
+    const goal = ROW_ACTIONS.has(action) && g && g.el === el && g.caret === caret ? g.x : null;
     const rows = multiline && ROW_ACTIONS.has(action) ? this.textareaRows(el, cl) : null;
-    const p = plan(text2, action, rows, goal);
+    const p = plan(text2, action, rows, goal, what.extend);
     this.goal = p.kind === "move" && p.goal !== void 0 ? { el, caret: p.to, x: p.goal } : null;
-    if (p.kind === "move") el.setSelectionRange(at[p.to], at[p.to]);
-    else if (p.kind === "replace") this.replace(el, at[p.from], at[p.to], p.text);
+    if (p.kind === "move") {
+      const a = p.anchor ?? p.to;
+      el.setSelectionRange(at[Math.min(a, p.to)], at[Math.max(a, p.to)], a > p.to ? "backward" : "forward");
+    } else if (p.kind === "replace") this.replace(el, at[p.from], at[p.to], p.text);
   }
   /** Replaces code units `from` to `to` of a field's value with `text`, the
    * caret after it, as typing does. */
@@ -2177,6 +2234,10 @@ var Surface = class {
       d.execCommand("insertLineBreak", false);
       return;
     }
+    if (action === "select-all") {
+      sel.selectAllChildren(host);
+      return;
+    }
     const within = () => sel.focusNode !== null && host.contains(sel.focusNode);
     const next = (dir) => {
       const [an, ao, fn, fo] = [sel.anchorNode, sel.anchorOffset, sel.focusNode, sel.focusOffset];
@@ -2186,26 +2247,26 @@ var Surface = class {
       sel.setBaseAndExtent(an, ao, fn, fo);
       return c;
     };
-    const walk = (alter, dir, go) => {
+    const walk = (alter2, dir, go) => {
       for (let i = 0; i < 1e5; i++) {
         const c = next(dir);
         if (!c || !go(c)) return;
-        sel.modify(alter, dir, "character");
+        sel.modify(alter2, dir, "character");
       }
     };
-    const back = (alter, unit) => {
+    const back = (alter2, unit) => {
       if (unit === "word") {
-        walk(alter, "backward", isSpace);
-        walk(alter, "backward", (c) => !isSpace(c));
-      } else if (unit === "line") walk(alter, "backward", (c) => !isBreak(c));
-      else sel.modify(alter, "backward", "character");
+        walk(alter2, "backward", isSpace);
+        walk(alter2, "backward", (c) => !isSpace(c));
+      } else if (unit === "line") walk(alter2, "backward", (c) => !isBreak(c));
+      else sel.modify(alter2, "backward", "character");
     };
-    const forward = (alter, unit) => {
+    const forward = (alter2, unit) => {
       if (unit === "word") {
-        walk(alter, "forward", isSpace);
-        walk(alter, "forward", (c) => !isSpace(c));
-      } else if (unit === "line") walk(alter, "forward", (c) => !isBreak(c));
-      else sel.modify(alter, "forward", "character");
+        walk(alter2, "forward", isSpace);
+        walk(alter2, "forward", (c) => !isSpace(c));
+      } else if (unit === "line") walk(alter2, "forward", (c) => !isBreak(c));
+      else sel.modify(alter2, "forward", "character");
     };
     if (action.startsWith("delete-")) {
       if (sel.isCollapsed) {
@@ -2217,28 +2278,29 @@ var Surface = class {
       return;
     }
     const backward = ["char-backward", "word-backward", "line-start", "line-previous", "page-up", "input-start"].includes(action);
-    if (!sel.isCollapsed) {
+    const alter = what.extend ? "extend" : "move";
+    if (!what.extend && !sel.isCollapsed) {
       if (backward) sel.collapseToStart();
       else sel.collapseToEnd();
       if (action === "char-backward" || action === "char-forward") return;
     }
     const by = { "char-backward": "char", "char-forward": "char", "word-backward": "word", "word-forward": "word", "line-start": "line", "line-end": "line" }[action];
     if (by) {
-      if (backward) back("move", by);
-      else forward("move", by);
+      if (backward) back(alter, by);
+      else forward(alter, by);
       return;
     }
     if (action === "input-start" || action === "input-end") {
-      sel.modify("move", backward ? "backward" : "forward", "documentboundary");
+      sel.modify(alter, backward ? "backward" : "forward", "documentboundary");
       return;
     }
     if (ROW_ACTIONS.has(action)) {
       const rows = action.startsWith("page") ? Math.max(1, Math.round(host.clientHeight / (parseFloat(this.frame.contentWindow.getComputedStyle(host).lineHeight) || 16))) : 1;
       for (let i = 0; i < rows; i++) {
         const [fn, fo] = [sel.focusNode, sel.focusOffset];
-        sel.modify("move", backward ? "backward" : "forward", "line");
+        sel.modify(alter, backward ? "backward" : "forward", "line");
         if (sel.focusNode === fn && sel.focusOffset === fo) {
-          sel.modify("move", backward ? "backward" : "forward", "documentboundary");
+          sel.modify(alter, backward ? "backward" : "forward", "documentboundary");
           return;
         }
       }
@@ -3126,6 +3188,12 @@ function keyText(key) {
   const v = key.endsWith("++") ? "+" : key.slice(key.lastIndexOf("+") + 1);
   return v === "Space" ? " " : v;
 }
+function typesNoText(e) {
+  if (e.getModifierState?.("AltGraph")) return false;
+  if ([...e.key].length === 1) return e.ctrlKey || e.metaKey;
+  return !NOT_KEYS.has(e.key);
+}
+var NOT_KEYS = /* @__PURE__ */ new Set(["Unidentified", "Dead", "Process", "Compose", "Shift", "Control", "Alt", "AltGraph", "Meta", "OS", "Super", "Hyper", "Fn", "FnLock", "CapsLock", "NumLock", "ScrollLock", "Symbol", "SymbolLock"]);
 function domKeyName(e) {
   const char = [...e.key].length === 1;
   const mods = [e.ctrlKey && "Control", e.altKey && "Alt", e.metaKey && "Meta", e.shiftKey && !char && "Shift"].filter(Boolean);