@cnwenf/occ 2.1.308 → 2.1.309

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-globalThis.MACRO={"VERSION":"2.1.308","BINARY_NAME":"occ","BUILD_TIME":"2026-08-21T18:25:57.305Z","FEEDBACK_CHANNEL":"","ISSUES_EXPLAINER":"","NATIVE_PACKAGE_URL":"","PACKAGE_URL":"@cnwenf/occ","VERSION_CHANGELOG":""};
+globalThis.MACRO={"VERSION":"2.1.309","BINARY_NAME":"occ","BUILD_TIME":"2026-08-22T21:04:11.629Z","FEEDBACK_CHANNEL":"","ISSUES_EXPLAINER":"","NATIVE_PACKAGE_URL":"","PACKAGE_URL":"@cnwenf/occ","VERSION_CHANGELOG":""};
 // @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -452681,10 +452681,17 @@ var init_ink3 = __esm(() => {
 });
 
 // src/utils/srA11y.ts
-function announceDeletedText(deletedText, sink2 = pushScreenReaderAnnouncement) {
-  if (deletedText.length > 0) {
-    sink2(deletedText);
+function announceDeletedText(deletedText, mask = "", sink2 = pushScreenReaderAnnouncement) {
+  if (deletedText === "")
+    return;
+  if (mask !== "") {
+    sink2("deleted");
+    return;
   }
+  const announcement = deletedText.trim() === "" ? deletedText.includes(`
+`) ? "new line" : deletedText.includes("\t") ? "tab" : "space" : deletedText.replaceAll(`
+`, " ").trim();
+  sink2(announcement);
 }
 function srEchoTypedChar(char) {
   if (char === " ") {
@@ -637446,7 +637453,7 @@ class Cursor {
   left() {
     if (this.offset === 0)
       return this;
-    const chip = this.imageRefEndingAt(this.offset);
+    const chip = this.placeholderEndingAt(this.offset);
     if (chip)
       return new Cursor(this.measuredText, chip.start);
     const prevOffset = this.measuredText.prevOffset(this.offset);
@@ -637455,31 +637462,40 @@ class Cursor {
   right() {
     if (this.offset >= this.text.length)
       return this;
-    const chip = this.imageRefStartingAt(this.offset);
+    const chip = this.placeholderStartingAt(this.offset);
     if (chip)
       return new Cursor(this.measuredText, chip.end);
     const nextOffset = this.measuredText.nextOffset(this.offset);
     return new Cursor(this.measuredText, Math.min(nextOffset, this.text.length));
   }
-  imageRefEndingAt(offset) {
-    const m5 = this.text.slice(0, offset).match(/\[Image #\d+\]$/);
+  placeholderEndingAt(offset) {
+    if (this.text[offset - 1] !== "]")
+      return null;
+    const m5 = this.text.slice(0, offset).match(PLACEHOLDER_ENDING_RE);
     return m5 ? { start: offset - m5[0].length, end: offset } : null;
   }
-  imageRefStartingAt(offset) {
-    const m5 = this.text.slice(offset).match(/^\[Image #\d+\]/);
+  placeholderStartingAt(offset) {
+    if (this.text[offset] !== "[")
+      return null;
+    const m5 = this.text.slice(offset).match(PLACEHOLDER_STARTING_RE);
     return m5 ? { start: offset, end: offset + m5[0].length } : null;
   }
-  snapOutOfImageRef(offset, toward) {
-    const re3 = /\[Image #\d+\]/g;
-    let m5;
-    while ((m5 = re3.exec(this.text)) !== null) {
-      const start = m5.index;
+  placeholderContaining(offset) {
+    for (const m5 of this.text.matchAll(PLACEHOLDER_GLOBAL_RE)) {
+      const start = m5.index ?? 0;
       const end = start + m5[0].length;
-      if (offset > start && offset < end) {
-        return toward === "start" ? start : end;
-      }
+      if (offset > start && offset < end)
+        return { start, end };
+      if (start >= offset)
+        break;
     }
-    return offset;
+    return null;
+  }
+  snapOutOfPlaceholder(offset, toward) {
+    const chip = this.placeholderContaining(offset);
+    if (!chip)
+      return offset;
+    return toward === "start" ? chip.start : chip.end;
   }
   up() {
     const { line, column } = this.getPosition();
@@ -637615,10 +637631,15 @@ class Cursor {
     if (this.isAtEnd()) {
       return this;
     }
+    const chip = this.placeholderStartingAt(this.offset) ?? this.placeholderContaining(this.offset);
+    if (chip) {
+      return new Cursor(this.measuredText, chip.end);
+    }
     const wordBoundaries = this.measuredText.getWordBoundaries();
     for (const boundary of wordBoundaries) {
       if (boundary.isWordLike && boundary.start > this.offset) {
-        return new Cursor(this.measuredText, boundary.start);
+        const target = this.snapOutOfPlaceholder(boundary.start, "end");
+        return new Cursor(this.measuredText, target);
       }
     }
     return new Cursor(this.measuredText, this.text.length);
@@ -637654,6 +637675,14 @@ class Cursor {
     if (this.isAtStart()) {
       return this;
     }
+    const chipEnding = this.placeholderEndingAt(this.offset);
+    if (chipEnding) {
+      return new Cursor(this.measuredText, chipEnding.start);
+    }
+    const chipContaining = this.placeholderContaining(this.offset);
+    if (chipContaining) {
+      return new Cursor(this.measuredText, chipContaining.start);
+    }
     const wordBoundaries = this.measuredText.getWordBoundaries();
     let prevWordStart = null;
     for (const boundary of wordBoundaries) {
@@ -637661,13 +637690,15 @@ class Cursor {
         continue;
       if (boundary.start < this.offset) {
         if (this.offset > boundary.start && this.offset <= boundary.end) {
-          return new Cursor(this.measuredText, boundary.start);
+          const target = this.snapOutOfPlaceholder(boundary.start, "start");
+          return new Cursor(this.measuredText, target);
         }
         prevWordStart = boundary.start;
       }
     }
     if (prevWordStart !== null) {
-      return new Cursor(this.measuredText, prevWordStart);
+      const target = this.snapOutOfPlaceholder(prevWordStart, "start");
+      return new Cursor(this.measuredText, target);
     }
     return new Cursor(this.measuredText, 0);
   }
@@ -637804,6 +637835,64 @@ class Cursor {
     }
     return cursor;
   }
+  forwardWord() {
+    if (this.isAtEnd()) {
+      return this;
+    }
+    const chip = this.placeholderStartingAt(this.offset) ?? this.placeholderContaining(this.offset);
+    if (chip) {
+      return new Cursor(this.measuredText, chip.end);
+    }
+    for (const boundary of this.measuredText.getReadlineWordBoundaries()) {
+      if (boundary.end > this.offset) {
+        const target = this.snapOutOfPlaceholder(boundary.end, "end");
+        return new Cursor(this.measuredText, target);
+      }
+    }
+    return new Cursor(this.measuredText, this.text.length);
+  }
+  backwardWord() {
+    if (this.isAtStart()) {
+      return this;
+    }
+    const chip = this.placeholderEndingAt(this.offset) ?? this.placeholderContaining(this.offset);
+    if (chip) {
+      return new Cursor(this.measuredText, chip.start);
+    }
+    const boundaries = this.measuredText.getReadlineWordBoundaries();
+    for (let i6 = boundaries.length - 1;i6 >= 0; i6--) {
+      const boundary = boundaries[i6];
+      if (boundary.start < this.offset) {
+        const target = this.snapOutOfPlaceholder(boundary.start, "start");
+        return new Cursor(this.measuredText, target);
+      }
+    }
+    return new Cursor(this.measuredText, 0);
+  }
+  killWord() {
+    const target = this.forwardWord();
+    if (target.offset === this.offset) {
+      return { cursor: this, killed: "" };
+    }
+    return this.killRange(this.offset, target.offset);
+  }
+  backwardKillWord() {
+    const target = this.backwardWord();
+    if (target.offset === this.offset) {
+      return { cursor: this, killed: "" };
+    }
+    return this.killRange(target.offset, this.offset);
+  }
+  killRange(start, end) {
+    const snappedStart = this.snapOutOfPlaceholder(start, "start");
+    const snappedEnd = this.snapOutOfPlaceholder(end, "end");
+    const startCursor = new Cursor(this.measuredText, snappedStart);
+    const endCursor = new Cursor(this.measuredText, snappedEnd);
+    return {
+      cursor: startCursor.modifyText(endCursor),
+      killed: this.text.slice(snappedStart, snappedEnd)
+    };
+  }
   modifyText(end, insertString = "") {
     const startOffset = this.offset;
     const endOffset = end.offset;
@@ -637833,8 +637922,7 @@ class Cursor {
 ` };
     }
     const startCursor = this.startOfLine();
-    const killed = this.text.slice(startCursor.offset, this.offset);
-    return { cursor: startCursor.modifyText(this), killed };
+    return this.killRange(startCursor.offset, this.offset);
   }
   deleteToLineEnd() {
     if (this.text[this.offset] === `
@@ -637843,36 +637931,29 @@ class Cursor {
 ` };
     }
     const endCursor = this.endOfLine();
-    const killed = this.text.slice(this.offset, endCursor.offset);
-    return { cursor: this.modifyText(endCursor), killed };
+    return this.killRange(this.offset, endCursor.offset);
   }
   deleteToLogicalLineEnd() {
     if (this.text[this.offset] === `
 `) {
       return this.modifyText(this.right());
     }
-    return this.modifyText(this.endOfLogicalLine());
+    return this.killRange(this.offset, this.endOfLogicalLine().offset).cursor;
   }
   deleteWordBefore() {
     if (this.isAtStart()) {
       return { cursor: this, killed: "" };
     }
-    const target = this.snapOutOfImageRef(this.prevWord().offset, "start");
-    const prevWordCursor = new Cursor(this.measuredText, target);
-    const killed = this.text.slice(prevWordCursor.offset, this.offset);
-    return { cursor: prevWordCursor.modifyText(this), killed };
+    return this.killRange(this.prevWord().offset, this.offset);
   }
   deleteWORDBefore() {
     if (this.isAtStart()) {
       return { cursor: this, killed: "" };
     }
-    const target = this.snapOutOfImageRef(this.prevWORD().offset, "start");
-    const prevWORDCursor = new Cursor(this.measuredText, target);
-    const killed = this.text.slice(prevWORDCursor.offset, this.offset);
-    return { cursor: prevWORDCursor.modifyText(this), killed };
+    return this.killRange(this.prevWORD().offset, this.offset);
   }
   deleteTokenBefore() {
-    const chipAfter = this.imageRefStartingAt(this.offset);
+    const chipAfter = this.placeholderStartingAt(this.offset);
     if (chipAfter) {
       const end = this.text[chipAfter.end] === " " ? chipAfter.end + 1 : chipAfter.end;
       return this.modifyText(new Cursor(this.measuredText, end));
@@ -637885,7 +637966,7 @@ class Cursor {
       return null;
     }
     const textBefore = this.text.slice(0, this.offset);
-    const pasteMatch = textBefore.match(/(^|\s)\[(Pasted text #\d+(?: \+\d+ lines)?|Image #\d+|\.\.\.Truncated text #\d+ \+\d+ lines\.\.\.)\]$/);
+    const pasteMatch = textBefore.match(/(^|\s)\[(Pasted text #\d+(?: \+\d+ lines)?|Image #\d+|Audio #\d+|\.\.\.Truncated text #\d+ \+\d+ lines\.\.\.)\]$/);
     if (pasteMatch) {
       const matchStart = pasteMatch.index + pasteMatch[1].length;
       return new Cursor(this.measuredText, matchStart).modifyText(this);
@@ -637896,8 +637977,7 @@ class Cursor {
     if (this.isAtEnd()) {
       return this;
     }
-    const target = this.snapOutOfImageRef(this.nextWord().offset, "end");
-    return this.modifyText(new Cursor(this.measuredText, target));
+    return this.killRange(this.offset, this.nextWord().offset).cursor;
   }
   graphemeAt(pos) {
     if (pos >= this.text.length)
@@ -638052,6 +638132,31 @@ class MeasuredText {
     }
     return this.wordBoundariesCache;
   }
+  readlineWordBoundariesCache;
+  getReadlineWordBoundaries() {
+    if (!this.readlineWordBoundariesCache) {
+      const boundaries = [];
+      let snappedPrev = false;
+      for (const word of this.getWordBoundaries()) {
+        const wordText = this.text.slice(word.start, word.end);
+        for (const match of wordText.matchAll(READLINE_WORD_RE)) {
+          const start = this.snapToGraphemeBoundary(word.start + match.index);
+          const rawEnd = word.start + match.index + match[0].length;
+          const snappedEnd = this.snapToGraphemeBoundary(rawEnd);
+          const end = snappedEnd === rawEnd ? rawEnd : this.nextOffset(snappedEnd);
+          const last3 = boundaries.at(-1);
+          if (last3 && (start < last3.end || start === last3.end && snappedPrev)) {
+            last3.end = Math.max(last3.end, end);
+          } else {
+            boundaries.push({ start, end });
+          }
+          snappedPrev = end !== rawEnd;
+        }
+      }
+      this.readlineWordBoundariesCache = boundaries;
+    }
+    return this.readlineWordBoundariesCache;
+  }
   binarySearchBoundary(boundaries, target, findNext) {
     let left2 = 0;
     let right2 = boundaries.length - 1;
@@ -638274,11 +638379,16 @@ class MeasuredText {
     return boundaries[lo];
   }
 }
-var KILL_RING_MAX_SIZE = 10, killRing, killRingIndex = 0, lastActionWasKill = false, lastYankStart = 0, lastYankLength = 0, lastActionWasYank = false, VIM_WORD_CHAR_REGEX, WHITESPACE_REGEX2, isVimWordChar = (ch2) => VIM_WORD_CHAR_REGEX.test(ch2), isVimWhitespace = (ch2) => WHITESPACE_REGEX2.test(ch2), isVimPunctuation = (ch2) => ch2.length > 0 && !isVimWhitespace(ch2) && !isVimWordChar(ch2);
+var PLACEHOLDER_PATTERN, PLACEHOLDER_ENDING_RE, PLACEHOLDER_STARTING_RE, PLACEHOLDER_GLOBAL_RE, READLINE_WORD_RE, KILL_RING_MAX_SIZE = 10, killRing, killRingIndex = 0, lastActionWasKill = false, lastYankStart = 0, lastYankLength = 0, lastActionWasYank = false, VIM_WORD_CHAR_REGEX, WHITESPACE_REGEX2, isVimWordChar = (ch2) => VIM_WORD_CHAR_REGEX.test(ch2), isVimWhitespace = (ch2) => WHITESPACE_REGEX2.test(ch2), isVimPunctuation = (ch2) => ch2.length > 0 && !isVimWhitespace(ch2) && !isVimWordChar(ch2);
 var init_Cursor = __esm(() => {
   init_stringWidth();
   init_wrapAnsi();
   init_intl();
+  PLACEHOLDER_PATTERN = String.raw`\[(?:Pasted text|Image|Audio|\.\.\.Truncated text) #\d+(?: \+\d+ lines)?\.*\]`;
+  PLACEHOLDER_ENDING_RE = new RegExp(PLACEHOLDER_PATTERN + "$");
+  PLACEHOLDER_STARTING_RE = new RegExp("^" + PLACEHOLDER_PATTERN);
+  PLACEHOLDER_GLOBAL_RE = new RegExp(PLACEHOLDER_PATTERN, "g");
+  READLINE_WORD_RE = /[\p{L}\p{N}][\p{L}\p{N}\p{M}]*/gu;
   killRing = [];
   VIM_WORD_CHAR_REGEX = /^[\p{L}\p{N}\p{M}_]$/u;
   WHITESPACE_REGEX2 = /\s/;
@@ -638432,7 +638542,7 @@ function useTextInput({
     removeNotification("escape-again-to-clear");
     onClearInput?.();
     if (originalValue) {
-      if (originalValue.trim() !== "") {
+      if (mask === "" && originalValue.trim() !== "") {
         addToHistory(originalValue);
       }
       onChange("");
@@ -638458,16 +638568,23 @@ function useTextInput({
     }
     return cursor.del();
   }
+  function recordKill(killed, direction) {
+    if (mask === "") {
+      pushToKillRing(killed, direction);
+    } else {
+      resetKillAccumulation();
+    }
+    announceDeletedText(killed, mask);
+  }
   function killToLineEnd() {
     const { cursor: newCursor, killed } = cursor.deleteToLineEnd();
-    pushToKillRing(killed, "append");
-    announceDeletedText(killed);
+    recordKill(killed, "append");
     return newCursor;
   }
   function killToLineStart() {
     const { cursor: newCursor, killed } = cursor.deleteToLineStart();
-    pushToKillRing(killed, "prepend");
-    if (killed.length >= 3) {
+    recordKill(killed, "prepend");
+    if (mask === "" && killed.length >= 3) {
       addNotification({
         key: "kill-paste-hint",
         text: "Ctrl+Y to paste deleted text",
@@ -638475,19 +638592,26 @@ function useTextInput({
         timeoutMs: 5000
       });
     }
-    announceDeletedText(killed);
     return newCursor;
   }
   function killWordBefore() {
     const { cursor: newCursor, killed } = cursor.deleteWordBefore();
-    pushToKillRing(killed, "prepend");
-    announceDeletedText(killed);
+    recordKill(killed, "prepend");
     return newCursor;
   }
   function killWORDBefore() {
     const { cursor: newCursor, killed } = cursor.deleteWORDBefore();
-    pushToKillRing(killed, "prepend");
-    announceDeletedText(killed);
+    recordKill(killed, "prepend");
+    return newCursor;
+  }
+  function killWordBeforeFlavored() {
+    const { cursor: newCursor, killed } = isReadline ? cursor.backwardKillWord() : cursor.deleteWordBefore();
+    recordKill(killed, "prepend");
+    return newCursor;
+  }
+  function killWordAfter() {
+    const { cursor: newCursor, killed } = cursor.killWord();
+    recordKill(killed, "append");
     return newCursor;
   }
   function yank() {
@@ -638529,9 +638653,9 @@ function useTextInput({
     ["y", yank]
   ]);
   const handleMeta = mapInput([
-    ["b", () => cursor.prevWord()],
-    ["f", () => cursor.nextWord()],
-    ["d", () => cursor.deleteWordAfter()],
+    ["b", () => isReadline ? cursor.backwardWord() : cursor.prevWord()],
+    ["f", () => isReadline ? cursor.forwardWord() : cursor.nextWord()],
+    ["d", isReadline ? killWordAfter : () => cursor.deleteWordAfter()],
     ["y", handleYankPop]
   ]);
   function handleEnter(key4) {
@@ -638596,13 +638720,13 @@ function useTextInput({
           return cursor;
         };
       case (key4.leftArrow && (key4.ctrl || key4.meta || key4.fn)):
-        return () => cursor.prevWord();
+        return () => isReadline ? cursor.backwardWord() : cursor.prevWord();
       case (key4.rightArrow && (key4.ctrl || key4.meta || key4.fn)):
-        return () => cursor.nextWord();
+        return () => isReadline ? cursor.forwardWord() : cursor.nextWord();
       case key4.backspace:
-        return key4.meta || key4.ctrl ? killWordBefore : () => cursor.deleteTokenBefore() ?? cursor.backspace();
+        return key4.super ? killToLineStart : key4.meta || key4.ctrl ? killWordBeforeFlavored : () => cursor.deleteTokenBefore() ?? cursor.backspace();
       case key4.delete:
-        return key4.meta ? killToLineEnd : () => cursor.del();
+        return key4.super || key4.meta ? killToLineEnd : () => cursor.del();
       case key4.ctrl:
         return handleCtrl;
       case key4.home:
@@ -638665,7 +638789,13 @@ function useTextInput({
     if (key4.ctrl && (input2 === "k" || input2 === "u" || input2 === "w")) {
       return true;
     }
-    if (key4.meta && (key4.backspace || key4.delete)) {
+    if (isReadline && key4.meta && !key4.ctrl && input2 === "d") {
+      return true;
+    }
+    if (key4.backspace && (key4.meta || key4.super || key4.ctrl)) {
+      return true;
+    }
+    if (key4.delete && (key4.meta || key4.super)) {
       return true;
     }
     return false;
@@ -649222,11 +649352,14 @@ var init_SearchBox = __esm(() => {
 });
 
 // src/hooks/useSearchInput.ts
-function isKillKey(e4) {
+function isKillKey(e4, isReadline) {
   if (e4.ctrl && (e4.key === "k" || e4.key === "u" || e4.key === "w")) {
     return true;
   }
-  if (e4.meta && e4.key === "backspace") {
+  if ((e4.meta || e4.ctrl) && e4.key === "backspace") {
+    return true;
+  }
+  if (isReadline && e4.meta && !e4.ctrl && e4.key.toLowerCase() === "d") {
     return true;
   }
   return false;
@@ -649257,15 +649390,15 @@ function useSearchInput({
     if (!isActive)
       return;
     const cursor = Cursor.fromText(query2, effectiveColumns, cursorOffset);
-    if (e4.ctrl && passthroughCtrlKeys.includes(e4.key.toLowerCase())) {
-      return;
-    }
-    if (!isKillKey(e4)) {
+    if (!isKillKey(e4, isReadline)) {
       resetKillAccumulation();
     }
     if (!isYankKey(e4)) {
       resetYankState();
     }
+    if (e4.ctrl && passthroughCtrlKeys.includes(e4.key.toLowerCase())) {
+      return;
+    }
     if (e4.key === "return" || e4.key === "down") {
       e4.preventDefault();
       onExit2();
@@ -649292,8 +649425,8 @@ function useSearchInput({
     }
     if (e4.key === "backspace") {
       e4.preventDefault();
-      if (e4.meta) {
-        const { cursor: newCursor2, killed } = cursor.deleteWordBefore();
+      if (e4.meta || e4.ctrl) {
+        const { cursor: newCursor2, killed } = isReadline ? cursor.backwardKillWord() : cursor.deleteWordBefore();
         pushToKillRing(killed, "prepend");
         setQueryState(newCursor2.text);
         setCursorOffset(newCursor2.offset);
@@ -649318,13 +649451,13 @@ function useSearchInput({
     }
     if (e4.key === "left" && (e4.ctrl || e4.meta || e4.fn)) {
       e4.preventDefault();
-      const newCursor = cursor.prevWord();
+      const newCursor = isReadline ? cursor.backwardWord() : cursor.prevWord();
       setCursorOffset(newCursor.offset);
       return;
     }
     if (e4.key === "right" && (e4.ctrl || e4.meta || e4.fn)) {
       e4.preventDefault();
-      const newCursor = cursor.nextWord();
+      const newCursor = isReadline ? cursor.forwardWord() : cursor.nextWord();
       setCursorOffset(newCursor.offset);
       return;
     }
@@ -649431,12 +649564,19 @@ function useSearchInput({
       e4.preventDefault();
       switch (e4.key.toLowerCase()) {
         case "b":
-          setCursorOffset(cursor.prevWord().offset);
+          setCursorOffset((isReadline ? cursor.backwardWord() : cursor.prevWord()).offset);
           return;
         case "f":
-          setCursorOffset(cursor.nextWord().offset);
+          setCursorOffset((isReadline ? cursor.forwardWord() : cursor.nextWord()).offset);
           return;
         case "d": {
+          if (isReadline) {
+            const { cursor: newCursor2, killed } = cursor.killWord();
+            pushToKillRing(killed, "append");
+            setQueryState(newCursor2.text);
+            setCursorOffset(newCursor2.offset);
+            return;
+          }
           const newCursor = cursor.deleteWordAfter();
           setQueryState(newCursor.text);
           setCursorOffset(newCursor.offset);
@@ -769751,8 +769891,8 @@ function getOperatorRange(cursor, target, motion, op, count4) {
   } else if (isInclusiveMotion(motion) && cursor.offset <= target.offset) {
     to = cursor.measuredText.nextOffset(to);
   }
-  from2 = cursor.snapOutOfImageRef(from2, "start");
-  to = cursor.snapOutOfImageRef(to, "end");
+  from2 = cursor.snapOutOfPlaceholder(from2, "start");
+  to = cursor.snapOutOfPlaceholder(to, "end");
   return { from: from2, to, linewise };
 }
 function getOperatorRangeForFind(cursor, target, _findType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cnwenf/occ",
-  "version": "2.1.308",
+  "version": "2.1.309",
   "license": "MIT",
   "type": "module",
   "bin": {