@lvce-editor/static-server 0.59.0 → 0.59.2

package/static/{91d96a2 → d75c78c}/packages/find-widget-worker/dist/findWidgetWorkerMain.js

@@ -378,7 +378,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -397,7 +397,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$2(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -477,7 +477,8 @@ const splitLines = lines => {
   return lines.split(NewLine);
 };
 const getCurrentStack = () => {
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(2));
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
 const getNewLineIndex = (string, startIndex = undefined) => {
@@ -741,13 +742,19 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke$1 = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
 const commands = Object.create(null);
 const register = commandMap => {
   Object.assign(commands, commandMap);
@@ -758,7 +765,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -774,10 +781,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$1(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -829,9 +836,30 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$3
 };
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    return command(...params);
+  };
+  const mockRpc = {
+    invoke,
+    invokeAndTransfer: invoke,
+    invocations
+  };
+  return mockRpc;
+};
 
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
 const create$2 = () => {
   const states = Object.create(null);
+  const commandMapRef = {};
   return {
     get(uid) {
       return states[uid];
@@ -872,6 +900,15 @@ const create$2 = () => {
       };
       return wrapped;
     },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
     diff(uid, modules, numbers) {
       const {
         oldState,
@@ -885,17 +922,32 @@ const create$2 = () => {
         }
       }
       return diffResult;
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
     }
   };
 };
+const terminate = () => {
+  globalThis.close();
+};
 
 const {
   get: get$1,
-  set: set$1,
+  set: set$3,
   wrapCommand,
-  dispose: dispose$1
+  dispose: dispose$2,
+  getCommandIds,
+  registerCommands,
+  wrapGetter
 } = create$2();
 
+const User$1 = 1;
 const Script$1 = 2;
 const Unknown = 0;
 
@@ -927,26 +979,38 @@ const create$1 = (uid, x, y, width, height, parentUid) => {
     editorY: y,
     editorWidth: width,
     editorHeight: height,
-    inputSource: 0
+    inputSource: 0,
+    preserveCase: false,
+    resizerPointerDown: false,
+    minWidth: 400,
+    history: []
   };
-  set$1(uid, state, state);
+  set$3(uid, state, state);
   return state;
 };
 
-const isEqual$5 = (oldState, newState) => {
+const isEqual$7 = (oldState, newState) => {
   return oldState.x === newState.x && oldState.y === newState.y && oldState.width === newState.width && oldState.height === newState.height;
 };
 
-const isEqual$4 = (oldState, newState) => {
+const isEqual$6 = (oldState, newState) => {
+  return newState.width === newState.width && oldState.height === newState.height && oldState.x === newState.x;
+};
+
+const isEqual$5 = (oldState, newState) => {
   return oldState.version === newState.version;
 };
 
+const isEqual$4 = (oldState, newState) => {
+  return oldState.focused === newState.focused && oldState.focus === newState.focus;
+};
+
 const isEqual$3 = (oldState, newState) => {
   return oldState.focused === newState.focused;
 };
 
 const isEqual$2 = (oldState, newState) => {
-  return oldState.version === newState.version && oldState.replaceExpanded === newState.replaceExpanded && oldState.matchCount === newState.matchCount && oldState.matchIndex === newState.matchIndex;
+  return oldState.version === newState.version && oldState.replaceExpanded === newState.replaceExpanded && oldState.matchCount === newState.matchCount && oldState.matchIndex === newState.matchIndex && oldState.matchCase === newState.matchCase && oldState.matchWholeWord === newState.matchWholeWord && oldState.useRegularExpression === newState.useRegularExpression && oldState.preserveCase === newState.preserveCase;
 };
 
 const isEqual$1 = (oldState, newState) => {
@@ -954,22 +1018,59 @@ const isEqual$1 = (oldState, newState) => {
 };
 
 const RenderBounds = 8;
+const RenderCss = 10;
 const RenderEventListeners = 11;
 const RenderUid = 12;
 const RenderContent = 13;
 const RenderFocusContext = 14;
 const RenderFocus = 15;
 const RenderValue = 16;
+const RenderReplaceValue = 17;
+
+const CheckBox = 'checkbox';
+const Group = 'group';
+const None = 'none';
+
+const Button = 1;
+const Div = 4;
+const Text = 12;
+const TextArea = 62;
+
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+const TargetName = 'event.target.name';
+
+const User = 1;
+const Script = 2;
+
+const EditorWorker$1 = 99;
 
-const Script = 1;
-const User = 2;
+const FocusSelector = 'Viewlet.focusSelector';
+const SetCss = 'Viewlet.setCss';
+const SetFocusContext = 'Viewlet.setFocusContext';
+const SetValueByName = 'Viewlet.setValueByName';
+
+const FocusFindWidgetCloseButton$1 = 48;
+const FocusIgnoreFiles = 1012;
+const FocusSearchExcludeInput = 1008;
+const FocusSearchIncludeInput = 1007;
+const FocusSearchInput = 21;
+const FocusSearchMatchCase = 32;
+const FocusSearchOpenEditors = 1011;
+const FocusSearchPreserveCase = 36;
+const FocusSearchRegex = 33;
+const FocusSearchReplaceAll = 35;
+const FocusSearchReplaceInput = 31;
+const FocusSearchWholeWord = 34;
+const FocusToggleDetails = 1010;
+const FocusToggleReplace = 1020;
 
 const isEqual = (oldState, newState) => {
   return newState.inputSource === User || oldState.value === newState.value;
 };
 
-const modules = [isEqual$4, isEqual$2, isEqual$5, isEqual$1, isEqual$3, isEqual$3, isEqual];
-const numbers = [RenderEventListeners, RenderContent, RenderBounds, RenderUid, RenderFocusContext, RenderFocus, RenderValue];
+const modules = [isEqual$5, isEqual$2, isEqual$7, isEqual$1, isEqual$3, isEqual$4, isEqual, isEqual$6];
+const numbers = [RenderEventListeners, RenderContent, RenderBounds, RenderUid, RenderFocusContext, RenderFocus, RenderValue, RenderCss];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -991,8 +1092,8 @@ const diff2 = uid => {
   return diffResult;
 };
 
-const dispose = uid => {
-  return dispose$1(uid);
+const dispose$1 = uid => {
+  return dispose$2(uid);
 };
 
 const FocusFindWidgetCloseButton = 48;
@@ -1015,15 +1116,13 @@ const focusCloseButton = state => {
 };
 
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
 const create = rpcId => {
   return {
     // @ts-ignore
@@ -1039,7 +1138,7 @@ const create = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$g(rpcId, rpc);
+      set$2(rpcId, rpc);
     },
     async dispose() {
       const rpc = get(rpcId);
@@ -1047,14 +1146,109 @@ const create = rpcId => {
     }
   };
 };
-const EditorWorker$1 = 99;
+
 const {
-  invoke: invoke$d,
-  set: set$c} = create(EditorWorker$1);
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$1,
+  dispose
+} = create(EditorWorker$1);
+const sendMessagePortToExtensionHostWorker = async port => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer(
+  // @ts-ignore
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0);
+};
+// TODO add tests for this
+const activateByEvent = async event => {
+  // @ts-ignore
+  await invoke$1('ActivateByEvent.activateByEvent', event);
+};
+const applyEdit = async (editorUid, changes) => {
+  // @ts-ignore
+  await invoke$1('Editor.applyEdit2', editorUid, changes);
+};
+const applyWorkspaceEdit = async (editorUid, changes) => {
+  // @ts-ignore
+  await invoke$1('Editor.applyWorkspaceEdit', editorUid, changes);
+};
+const closeWidget = async (editorUid, widgetId, widgetName, focusId) => {
+  // @ts-ignore
+  await invoke$1('Editor.closeWidget2', editorUid, widgetId, widgetName, focusId);
+};
+const getWordAt = async (uid, rowIndex, columnIndex) => {
+  // @ts-ignore
+  const word = await invoke$1('Editor.getWordAt2', uid, rowIndex, columnIndex);
+  return word;
+};
+const getLines$1 = async editorUid => {
+  const lines = await invoke$1('Editor.getLines2', editorUid);
+  return lines;
+};
+const getPositionAtCursor = async parentUid => {
+  const position = await invoke$1('Editor.getPositionAtCursor', parentUid);
+  return position;
+};
+const getOffsetAtCursor = async editorId => {
+  // @ts-ignore
+  return await invoke$1('Editor.getOffsetAtCursor', editorId);
+};
+const getSelections$1 = async editorUid => {
+  const selections = await invoke$1('Editor.getSelections2', editorUid);
+  return selections;
+};
+const getWordAtOffset2 = async editorUid => {
+  return invoke$1('Editor.getWordAtOffset2', editorUid);
+};
+const getWordBefore = async (editorUid, rowIndex, columnIndex) => {
+  return invoke$1('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
+};
+const updateDebugInfo = async info => {
+  await invoke$1('Editor.updateDebugInfo', info);
+};
+const getUri = async editorUid => {
+  // @ts-ignore
+  return invoke$1('Editor.getUri', editorUid);
+};
+const getLanguageId = async editorUid => {
+  // @ts-ignore
+  return invoke$1('Editor.getLanguageId', editorUid);
+};
+const getProblems = async () => {
+  // @ts-ignore
+  return invoke$1('Editor.getProblems');
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$1(mockRpc);
+  return mockRpc;
+};
+
 const EditorWorker = {
   __proto__: null,
-  invoke: invoke$d,
-  set: set$c
+  activateByEvent,
+  applyEdit,
+  applyWorkspaceEdit,
+  closeWidget,
+  dispose,
+  getLanguageId,
+  getLines: getLines$1,
+  getOffsetAtCursor,
+  getPositionAtCursor,
+  getProblems,
+  getSelections: getSelections$1,
+  getUri,
+  getWordAt,
+  getWordAtOffset2,
+  getWordBefore,
+  invoke: invoke$1,
+  invokeAndTransfer,
+  registerMockRpc,
+  sendMessagePortToExtensionHostWorker,
+  set: set$1,
+  updateDebugInfo
 };
 
 const {
@@ -1132,17 +1326,21 @@ const handleBlur = async state => {
   };
 };
 
-const close$1 = async state => {
-  const {
-    editorUid
-  } = state;
+const escapeRegExpCharacters = value => {
   // @ts-ignore
-  await invoke('Editor.closeFind2', editorUid);
-  return state;
+  return RegExp.escape(value);
 };
 
-const handleClickClose = state => {
-  return close$1(state);
+const buildRegex = (searchString, options) => {
+  const {
+    matchCase,
+    useRegularExpression,
+    matchWholeWord
+  } = options;
+  const flags = matchCase ? 'g' : 'gi';
+  const pattern = useRegularExpression ? searchString : escapeRegExpCharacters(searchString);
+  const wrapped = matchWholeWord ? `\\b(?:${pattern})\\b` : pattern;
+  return new RegExp(wrapped, flags);
 };
 
 const findRegexMatches = (lines, regex) => {
@@ -1167,22 +1365,11 @@ const findRegexMatches = (lines, regex) => {
   return new Uint32Array(matches);
 };
 
-const escapeRegExpCharacters = value => {
-  // @ts-ignore
-  return RegExp.escape(value);
-};
-
-const regexFlags = 'gi';
-const getSearchRegex = searchString => {
-  const escaped = escapeRegExpCharacters(searchString);
-  return new RegExp(escaped, regexFlags);
-};
-
-const findMatchesCaseInsensitive = (lines, searchString) => {
+const findMatches = (lines, searchString, options) => {
   if (searchString.length === 0) {
     return new Uint32Array([]);
   }
-  const regex = getSearchRegex(searchString);
+  const regex = buildRegex(searchString, options);
   return findRegexMatches(lines, regex);
 };
 
@@ -1190,11 +1377,19 @@ const getMatchCount = matches => {
   return matches.length / 2;
 };
 
-const refresh$1 = (state, value) => {
+const refresh$1 = (state, value, inputSource) => {
   const {
-    lines
+    lines,
+    matchCase,
+    useRegularExpression,
+    matchWholeWord
   } = state;
-  const matches = findMatchesCaseInsensitive(lines, value);
+  const options = {
+    matchCase,
+    useRegularExpression,
+    matchWholeWord
+  };
+  const matches = findMatches(lines, value, options);
   const matchCount = getMatchCount(matches);
   return {
     ...state,
@@ -1202,16 +1397,233 @@ const refresh$1 = (state, value) => {
     matchIndex: 0,
     matchCount,
     value,
-    inputSource: User
+    inputSource
+  };
+};
+
+const refresh = (state, value = state.value, inputSource = User) => {
+  return refresh$1(state, value, inputSource);
+};
+
+const toggleMatchCase = state => {
+  const {
+    matchCase
+  } = state;
+  const newState = {
+    ...state,
+    matchCase: !matchCase
+  };
+  return refresh(newState, newState.value, User);
+};
+
+const toggleMatchWholeWord = state => {
+  const {
+    matchWholeWord
+  } = state;
+  const newState = {
+    ...state,
+    matchWholeWord: !matchWholeWord
+  };
+  return refresh(newState, newState.value, User);
+};
+
+const togglePreserveCase = state => {
+  const {
+    preserveCase
+  } = state;
+  // TODO update search results
+  return {
+    ...state,
+    preserveCase: !preserveCase
+  };
+};
+
+const toggleUseRegularExpression = state => {
+  const {
+    useRegularExpression
+  } = state;
+  const newState = {
+    ...state,
+    useRegularExpression: !useRegularExpression
+  };
+  return refresh(newState, newState.value, User);
+};
+
+const Close$2 = 'Close';
+const FocusNext = 'FocusNext';
+const FocusPrevious = 'FocusPrevious';
+const MatchCase$2 = 'MatchCase';
+const MatchWholeWord$2 = 'MatchWholeWord';
+const PreserveCase$1 = 'PreserveCase';
+const Replace$2 = 'Replace';
+const ReplaceAll$2 = 'ReplaceAll';
+const ReplaceValue = 'replace-value';
+const SearchValue = 'search-value';
+const ToggleReplace$1 = 'ToggleReplace';
+const UseRegularExpression$2 = 'UseRegularExpression';
+
+const applyEdits = async (editorId, edits) => {
+  // @ts-ignore
+  await invoke('Editor.applyDocumentEdits', editorId, edits);
+};
+
+const getEdits = (matches, value, replacement, startIndex, replaceAll) => {
+  if (value.length === 0 || matches.length === 0) {
+    return [];
+  }
+  const edits = [];
+  const totalMatches = Math.floor(matches.length / 2);
+  const fromIndex = replaceAll ? 0 : Math.max(0, startIndex);
+  const toIndex = replaceAll ? totalMatches : Math.min(totalMatches, fromIndex + 1);
+  for (let i = fromIndex; i < toIndex; i++) {
+    const rowIndex = matches[i * 2];
+    const startColumnIndex = matches[i * 2 + 1];
+    const endColumnIndex = startColumnIndex + value.length;
+    edits.push({
+      start: {
+        rowIndex,
+        columnIndex: startColumnIndex
+      },
+      end: {
+        rowIndex,
+        columnIndex: endColumnIndex
+      },
+      inserted: [replacement],
+      deleted: [value],
+      origin: 'find-widget.replace'
+    });
+  }
+  return edits;
+};
+
+const replace$1 = async state => {
+  const {
+    matches,
+    value,
+    replacement,
+    matchIndex,
+    editorUid
+  } = state;
+  const edits = getEdits(matches, value, replacement, matchIndex, false);
+  await applyEdits(editorUid, edits);
+  // TODO ask editor worker to apply edit
+  // TODO ask editor worker for new lines?
+  return {
+    ...state
   };
 };
 
-const refresh = (state, value = state.value) => {
-  return refresh$1(state, value);
+const replaceAll$1 = state => {
+  const {
+    matches,
+    value,
+    replacement,
+    editorUid
+  } = state;
+  const edits = getEdits(matches, value, replacement, 0, true);
+  void applyEdits(editorUid, edits);
+  return {
+    ...state
+  };
+};
+
+const getClickHandler = name => {
+  switch (name) {
+    case Replace$2:
+      return replace$1;
+    case ReplaceAll$2:
+      return replaceAll$1;
+    case MatchCase$2:
+      return toggleMatchCase;
+    case MatchWholeWord$2:
+      return toggleMatchWholeWord;
+    case UseRegularExpression$2:
+      return toggleUseRegularExpression;
+    case PreserveCase$1:
+      return togglePreserveCase;
+    default:
+      throw new Error(`unexpected click`);
+  }
+};
+
+const handleClickButton = async (state, name) => {
+  const fn = getClickHandler(name);
+  return fn(state);
+};
+
+const close$1 = async state => {
+  const {
+    editorUid
+  } = state;
+  // @ts-ignore
+  await invoke('Editor.closeFind2', editorUid);
+  return state;
+};
+
+const handleClickClose = state => {
+  return close$1(state);
+};
+
+const handleInput = (state, value, inputSource = User) => {
+  return refresh(state, value, inputSource);
+};
+
+const handleFindWidgetFocus = (state, focusKey) => {
+  if (state.focus === focusKey) {
+    return state;
+  }
+  return {
+    ...state,
+    focus: focusKey,
+    focusSource: User$1
+  };
+};
+
+const handleReplaceFocus = state => {
+  return handleFindWidgetFocus(state, FocusFindWidgetReplace);
+};
+
+const handleResizerPointerDown = async (state, eventX, eventY) => {
+  return {
+    ...state,
+    resizerPointerDown: true
+  };
 };
 
-const handleInput = (state, value) => {
-  return refresh(state, value);
+const getNewCoordinates = (oldWidth, oldX, eventX, minWidth) => {
+  const oldXEnd = oldX + oldWidth;
+  const newWidth = Math.max(oldXEnd - eventX, minWidth);
+  return {
+    newWidth,
+    newX: eventX
+  };
+};
+const handleResizerPointerMove = async (state, eventX, eventY) => {
+  const {
+    width,
+    x,
+    resizerPointerDown,
+    minWidth
+  } = state;
+  if (!resizerPointerDown) {
+    return state;
+  }
+  const {
+    newWidth,
+    newX
+  } = getNewCoordinates(width, x, eventX, minWidth);
+  return {
+    ...state,
+    x: newX,
+    width: newWidth
+  };
+};
+
+const handleResizerPointerUp = async (state, eventX, eventY) => {
+  return {
+    ...state,
+    resizerPointerDown: false
+  };
 };
 
 const getFindWidgetHeight = replaceExpanded => {
@@ -1221,7 +1633,7 @@ const getFindWidgetHeight = replaceExpanded => {
   return newHeight;
 };
 
-const toggleReplace = state => {
+const toggleReplace$1 = state => {
   const {
     replaceExpanded
   } = state;
@@ -1234,10 +1646,128 @@ const toggleReplace = state => {
   };
 };
 
-const commandIds = ['handleSliderPointerDown', 'handleSliderPointerMove'];
+const focusElement = (state, whenExpression) => {
+  return {
+    ...state,
+    focus: whenExpression,
+    focusSource: Script
+  };
+};
 
-const getCommandIds = () => {
-  return commandIds;
+const getNextFocus = (focus, replaceExpanded) => {
+  switch (focus) {
+    case FocusToggleReplace:
+      return FocusSearchInput;
+    case FocusSearchInput:
+      if (replaceExpanded) {
+        return FocusSearchReplaceInput;
+      }
+      return FocusSearchMatchCase;
+    case FocusSearchMatchCase:
+      return FocusSearchWholeWord;
+    case FocusSearchWholeWord:
+      return FocusSearchRegex;
+    case FocusSearchRegex:
+      if (replaceExpanded) {
+        return FocusSearchPreserveCase;
+      }
+      return FocusFindWidgetCloseButton$1;
+    case FocusSearchReplaceInput:
+      return FocusSearchMatchCase;
+    case FocusSearchPreserveCase:
+      return FocusSearchReplaceAll;
+    case FocusSearchReplaceAll:
+      return FocusToggleDetails;
+    case FocusSearchIncludeInput:
+      return FocusSearchOpenEditors;
+    case FocusSearchOpenEditors:
+      return FocusSearchExcludeInput;
+    case FocusSearchExcludeInput:
+      return FocusIgnoreFiles;
+    case FocusToggleDetails:
+      return FocusSearchIncludeInput;
+    default:
+      return focus;
+  }
+};
+
+const focusNextElement = state => {
+  const {
+    focus,
+    replaceExpanded
+  } = state;
+  const nextFocus = getNextFocus(focus, replaceExpanded);
+  return focusElement(state, nextFocus);
+};
+
+const getPreviousFocus = (focus, replaceExpanded) => {
+  switch (focus) {
+    case FocusSearchInput:
+      return FocusToggleReplace;
+    case FocusSearchMatchCase:
+      if (replaceExpanded) {
+        return FocusSearchReplaceInput;
+      }
+      return FocusSearchInput;
+    case FocusSearchWholeWord:
+      return FocusSearchMatchCase;
+    case FocusSearchRegex:
+      return FocusSearchWholeWord;
+    case FocusSearchPreserveCase:
+      return FocusSearchRegex;
+    case FocusSearchReplaceInput:
+      return FocusSearchInput;
+    case FocusSearchReplaceAll:
+      return FocusSearchPreserveCase;
+    case FocusToggleDetails:
+      if (replaceExpanded) {
+        return FocusSearchReplaceAll;
+      }
+      return FocusSearchRegex;
+    case FocusSearchOpenEditors:
+      return FocusSearchIncludeInput;
+    case FocusSearchExcludeInput:
+      return FocusSearchOpenEditors;
+    case FocusIgnoreFiles:
+      return FocusSearchExcludeInput;
+    case FocusSearchIncludeInput:
+      return FocusToggleDetails;
+    case FocusFindWidgetCloseButton$1:
+      return FocusSearchRegex;
+    default:
+      return focus;
+  }
+};
+
+const focusPreviousElement = state => {
+  const {
+    focus,
+    replaceExpanded
+  } = state;
+  const previousFocus = getPreviousFocus(focus, replaceExpanded);
+  return focusElement(state, previousFocus);
+};
+
+const handleReplaceInput = (state, value, inputSource = User) => {
+  return {
+    ...state,
+    replacement: value,
+    inputSource
+  };
+};
+
+const regexFlags = 'gi';
+const getSearchRegex = searchString => {
+  const escaped = escapeRegExpCharacters(searchString);
+  return new RegExp(escaped, regexFlags);
+};
+
+const findMatchesCaseInsensitive = (lines, searchString) => {
+  if (searchString.length === 0) {
+    return new Uint32Array([]);
+  }
+  const regex = getSearchRegex(searchString);
+  return findRegexMatches(lines, regex);
 };
 
 const getFindWidgetPosition = (editorX, editorY, editorWidth) => {
@@ -1278,13 +1808,38 @@ const getSelections = async editorUid => {
   return selections;
 };
 
-const loadContent = async state => {
+const getSavedValue = savedState => {
+  if (savedState && savedState.value) {
+    return savedState.value;
+  }
+  return '';
+};
+const getSavedReplacement = savedState => {
+  if (savedState && savedState.replacement) {
+    return savedState.replacement;
+  }
+  return '';
+};
+const restoreState = savedState => {
+  const value = getSavedValue(savedState);
+  const replacement = getSavedReplacement(savedState);
+  return {
+    value,
+    replacement
+  };
+};
+
+const loadContent = async (state, savedState) => {
   const {
     editorUid,
     editorWidth,
     editorX,
     editorY
   } = state;
+  const {
+    replacement,
+    value
+  } = restoreState(savedState);
   const lines = await getLines(editorUid);
   const selections = await getSelections(editorUid);
   const {
@@ -1296,24 +1851,26 @@ const loadContent = async state => {
   if (lines.length === 0) {
     return state;
   }
-  const value = getSelectedText(lines, selections);
-  const matches = findMatchesCaseInsensitive(lines, value);
+  const actualValue = value || getSelectedText(lines, selections);
+  const matches = findMatchesCaseInsensitive(lines, actualValue);
   const matchCount = getMatchCount(matches);
   return {
     ...state,
-    value,
+    focus: FocusSearchInput,
+    focused: true,
+    height,
+    inputSource: Script,
+    lines,
+    matchCount,
     matches,
     matchIndex: 0,
-    matchCount,
+    replacement,
+    selections,
+    value: actualValue,
     version: 1,
-    x,
-    y,
     width,
-    height,
-    lines,
-    selections,
-    focused: true,
-    inputSource: Script
+    x,
+    y
   };
 };
 
@@ -1338,18 +1895,23 @@ const renderBounds = (oldState, newState) => {
 };
 
 const HandleBlur = 'handleBlur';
+const HandleClickButton = 'handleClickButton';
 const HandleClickClose = 'handleClickClose';
 const HandleClickNextMatch = 'handleClickNextMatch';
 const HandleClickPreviousMatch = 'handleClickPreviousMatch';
 const HandleClickReplace = 'handleClickReplace';
-const HandleClickToggleReplace = 'handleClickToggleReplace';
 const HandleClickReplaceAll = 'handleClickReplaceAll';
+const HandleClickToggleReplace = 'handleClickToggleReplace';
 const HandleFocus = 'handleFocus';
+const HandleFocusNext = 'handleFocusNext';
+const HandleFocusPrevious = 'handleFocusPrevious';
 const HandleInput = 'handleInput';
 const HandleReplaceFocus = 'handleReplaceFocus';
-const HandleFocusPrevious = 'handleFocusPrevious';
-const HandleFocusNext = 'handleFocusNext';
 const HandleReplaceInput = 'handleReplaceInput';
+const HandleResizerPointerDown = 'handleResizerPointerDown';
+const HandleResizerPointerMove = 'handleResizerPointerMove';
+const HandleResizerPointerUp = 'handleResizerPointerUp';
+const HandleToggleReplaceFocus = 'handleToggleReplaceFocus';
 
 const emptyObject = {};
 const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
@@ -1365,16 +1927,24 @@ const i18nString = (key, placeholders = emptyObject) => {
 
 const MatchOf = '{PH1} of {PH2}';
 const NoResults = 'No Results';
-const Close$2 = 'Close';
+const PreserveCase = 'Preserve Case';
+const Close$1 = 'Close';
 const PreviousMatch = 'Previous Match';
 const NextMatch = 'Next Match';
 const Find$1 = 'Find';
-const Replace$2 = 'Replace';
-const ReplaceAll$2 = 'Replace All';
+const Replace$1 = 'Replace';
+const ReplaceAll$1 = 'Replace All';
+const MatchCase$1 = 'Match Case';
+const MatchWholeWord$1 = 'Match Whole Word';
+const UseRegularExpression$1 = 'Use Regular Expression';
+const ToggleReplace = 'Toggle Replace';
 
 const noResults = () => {
   return i18nString(NoResults);
 };
+const preserveCase = () => {
+  return i18nString(PreserveCase);
+};
 const matchOf = (matchIndex, matchCount) => {
   return i18nString(MatchOf, {
     PH1: matchIndex,
@@ -1388,34 +1958,66 @@ const nextMatch = () => {
   return i18nString(NextMatch);
 };
 const close = () => {
-  return i18nString(Close$2);
+  return i18nString(Close$1);
 };
 const find = () => {
   return i18nString(Find$1);
 };
 const replace = () => {
-  return i18nString(Replace$2);
+  return i18nString(Replace$1);
 };
 const replaceAll = () => {
-  return i18nString(ReplaceAll$2);
+  return i18nString(ReplaceAll$1);
+};
+const matchCase = () => {
+  return i18nString(MatchCase$1);
+};
+const matchWholeWord = () => {
+  return i18nString(MatchWholeWord$1);
+};
+const useRegularExpression = () => {
+  return i18nString(UseRegularExpression$1);
+};
+const toggleReplace = () => {
+  return i18nString(ToggleReplace);
 };
 
+const MatchCase = 'CaseSensitive';
+const UseRegularExpression = 'Regex';
+const MatchWholeWord = 'WholeWord';
 const ArrowDown = 'ArrowDown';
 const ArrowUp = 'ArrowUp';
-const Close$1 = 'Close';
-const Replace$1 = 'Replace';
-const ReplaceAll$1 = 'ReplaceAll';
-
-const ToggleReplace = 'ToggleReplace';
-const SearchValue = 'search-value';
-const ReplaceValue = 'replace-value';
-const ReplaceAll = 'ReplaceAll';
 const Close = 'Close';
-const FocusNext = 'FocusNext';
-const FocusPrevious = 'FocusPrevious';
 const Replace = 'Replace';
+const ReplaceAll = 'ReplaceAll';
 
-const getFindWidgetButtons = (findButtonsEnabled, replaceButtonsEnabled) => {
+const getFindWidgetButtons = (findButtonsEnabled, replaceButtonsEnabled, matchCase$1, matchWholeWord$1, useRegularExpression$1, preserveCase$1) => {
+  const findFieldButtons = [{
+    checked: matchCase$1,
+    icon: MatchCase,
+    title: matchCase(),
+    name: MatchCase$2,
+    onClick: HandleClickButton
+  }, {
+    checked: matchWholeWord$1,
+    icon: MatchWholeWord,
+    title: matchWholeWord(),
+    name: MatchWholeWord$2,
+    onClick: HandleClickButton
+  }, {
+    checked: useRegularExpression$1,
+    icon: UseRegularExpression,
+    title: useRegularExpression(),
+    name: UseRegularExpression$2,
+    onClick: HandleClickButton
+  }];
+  const replaceFieldButtons = [{
+    checked: preserveCase$1,
+    icon: 'PreserveCase',
+    title: preserveCase(),
+    name: PreserveCase$1,
+    onClick: HandleClickButton
+  }];
   const findButtons = [{
     label: previousMatch(),
     icon: ArrowUp,
@@ -1430,27 +2032,29 @@ const getFindWidgetButtons = (findButtonsEnabled, replaceButtonsEnabled) => {
     name: FocusNext
   }, {
     label: close(),
-    icon: Close$1,
+    icon: Close,
     disabled: false,
     onClick: HandleClickClose,
-    name: Close
+    name: Close$2
   }];
   const replaceButtons = [{
     label: replace(),
-    icon: Replace$1,
+    icon: Replace,
     disabled: !replaceButtonsEnabled,
-    onClick: HandleClickReplace,
-    name: Replace
+    onClick: HandleClickButton,
+    name: Replace$2
   }, {
     label: replaceAll(),
-    icon: ReplaceAll$1,
+    icon: ReplaceAll,
     disabled: !replaceButtonsEnabled,
-    onClick: HandleClickReplaceAll,
-    name: ReplaceAll
+    onClick: HandleClickButton,
+    name: ReplaceAll$2
   }];
   return {
     findButtons,
-    replaceButtons
+    findFieldButtons,
+    replaceButtons,
+    replaceFieldButtons
   };
 };
 
@@ -1463,9 +2067,17 @@ const getFindWidgetButtonsEnabled = (matchCount, value) => {
   };
 };
 
-const CheckBox = 'checkbox';
-const Group = 'group';
-const None = 'none';
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
 
 const FindWidgetFind = 'FindWidgetFind';
 const FindWidgetMatchCount = 'FindWidgetMatchCount';
@@ -1484,18 +2096,12 @@ const Viewlet = 'Viewlet';
 const ViewletFind = 'ViewletFind';
 const FindWidget = 'FindWidget';
 const ViewletFindWidget = 'ViewletFindWidget';
-
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
-};
-const Text = 12;
-const text = data => {
-  return {
-    type: Text,
-    text: data,
-    childCount: 0
-  };
-};
+const Resizer = 'Resizer';
+const ResizerHighlight = 'ResizerHighlight';
+const SearchToggleButton = 'SearchToggleButton';
+const SearchToggleButtonExpanded = 'SearchToggleButtonExpanded';
+const MaskIconChevronDown = 'MaskIconChevronDown';
+const MaskIconChevronRight = 'MaskIconChevronRight';
 
 const getFindMatchCountClassName = (matchCount, value) => {
   if (value && matchCount === 0) {
@@ -1504,14 +2110,10 @@ const getFindMatchCountClassName = (matchCount, value) => {
   return FindWidgetMatchCount;
 };
 
-const Button = 1;
-const Div = 4;
-const TextArea = 62;
-
 const getIconVirtualDom = (icon, type = Div) => {
   return {
     type,
-    className: `MaskIcon MaskIcon${icon}`,
+    className: `${MaskIcon} MaskIcon${icon}`,
     role: None,
     childCount: 0
   };
@@ -1536,28 +2138,34 @@ const getIconButtonVirtualDom = iconButton => {
     ariaLabel: label,
     childCount: 1,
     disabled: disabled ? true : undefined,
-    onClick: onClick,
-    name: name
+    onClick,
+    name
   }, getIconVirtualDom(icon)];
 };
 
+const checkedClassName = mergeClassNames(SearchFieldButton, SearchFieldButtonChecked);
+const unCheckedClassName = SearchFieldButton;
 const getSearchFieldButtonVirtualDom = button => {
   const {
     icon,
     checked,
-    title
+    title,
+    name,
+    onClick
   } = button;
   return [{
-    type: Div,
-    className: mergeClassNames(SearchFieldButton, checked ? SearchFieldButtonChecked : ''),
-    title,
-    role: CheckBox,
+    type: Button,
     ariaChecked: checked,
+    className: checked ? checkedClassName : unCheckedClassName,
+    name,
+    role: CheckBox,
     tabIndex: 0,
-    childCount: 1
+    title,
+    childCount: 1,
+    onClick
   }, {
     type: Div,
-    className: mergeClassNames(MaskIcon, icon),
+    className: mergeClassNames(MaskIcon, `MaskIcon${icon}`),
     childCount: 0
   }];
 };
@@ -1590,73 +2198,74 @@ const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, out
   return dom;
 };
 
-const getFindWidgetFindVirtualDom = (matchCountText, buttons, matchCount, value) => {
-  const dom = [];
-  dom.push({
+const getFindWidgetFindVirtualDom = (matchCountText, buttons, fieldButtons, matchCount, value) => {
+  return [{
     type: Div,
     className: FindWidgetFind,
     childCount: 5
-  });
-  dom.push(...getSearchFieldVirtualDom('search-value', find(), HandleInput, [], [], HandleFocus));
-  const findClassName = getFindMatchCountClassName(matchCount, value);
-  dom.push({
+  }, ...getSearchFieldVirtualDom(SearchValue, find(), HandleInput, fieldButtons, [], HandleFocus), {
     type: Div,
-    className: findClassName,
+    className: getFindMatchCountClassName(matchCount, value),
     childCount: 1
-  }, text(matchCountText), ...buttons.flatMap(getIconButtonVirtualDom));
-  return dom;
+  }, text(matchCountText), ...buttons.flatMap(getIconButtonVirtualDom)];
 };
 
-const getFindWidgetReplaceVirtualDom = (replaceExpanded, replaceButtons) => {
-  const dom = [];
-  if (replaceExpanded) {
-    dom.push({
-      type: Div,
-      className: FindWidgetReplace,
-      childCount: 1 + replaceButtons.length
-    }, ...getSearchFieldVirtualDom(ReplaceValue, replace(), HandleReplaceInput, [], [], HandleReplaceFocus), ...replaceButtons.flatMap(getIconButtonVirtualDom));
+const getFindWidgetReplaceVirtualDom = (replaceExpanded, replaceButtons, replaceFieldButtons) => {
+  if (!replaceExpanded) {
+    return [];
   }
-  return dom;
+  return [{
+    type: Div,
+    className: FindWidgetReplace,
+    childCount: 1 + replaceButtons.length
+  }, ...getSearchFieldVirtualDom(ReplaceValue, replace(), HandleReplaceInput, [], [], HandleReplaceFocus), ...replaceButtons.flatMap(getIconButtonVirtualDom)];
+};
+
+const getResizerVirtualDom = () => {
+  return [{
+    type: Div,
+    className: Resizer,
+    childCount: 1,
+    onPointerDown: HandleResizerPointerDown
+  }, {
+    type: Div,
+    className: ResizerHighlight,
+    childCount: 0
+  }];
 };
 
 const getSearchToggleButtonVirtualDom = (replaceExpanded, onClick = '') => {
+  const title = toggleReplace();
   return [{
     type: Button,
-    className: `IconButton SearchToggleButton ${replaceExpanded ? 'SearchToggleButtonExpanded' : ''}`,
-    title: 'Toggle Replace',
-    ariaLabel: 'Toggle Replace',
+    className: mergeClassNames(IconButton, SearchToggleButton, replaceExpanded ? SearchToggleButtonExpanded : ''),
+    title,
+    ariaLabel: title,
     ariaExpanded: replaceExpanded,
-    name: ToggleReplace,
+    name: ToggleReplace$1,
     childCount: 1,
     'data-command': 'toggleReplace',
     onClick,
-    onFocus: 'handleToggleReplaceFocus'
+    onFocus: HandleToggleReplaceFocus
   }, {
     type: Div,
-    className: `MaskIcon ${replaceExpanded ? 'MaskIconChevronDown' : 'MaskIconChevronRight'}`,
+    className: mergeClassNames(MaskIcon, replaceExpanded ? MaskIconChevronDown : MaskIconChevronRight),
     childCount: 0
   }];
 };
 
-const getFindWidgetVirtualDom = (matchCountText, replaceExpanded, findButtons, replaceButtons, matchCase, matchWholeWord, useRegularExpression, matchCount, value) => {
-  const dom = [];
-  dom.push({
-    type: Div,
-    className: mergeClassNames(Viewlet, ViewletFind, ViewletFindWidget, FindWidget),
-    childCount: 2,
-    role: Group
-  });
-  dom.push(...getSearchToggleButtonVirtualDom(replaceExpanded, 'handleClickToggleReplace'));
-  dom.push({
+const parentNode = {
+  type: Div,
+  className: mergeClassNames(Viewlet, ViewletFind, ViewletFindWidget, FindWidget),
+  childCount: 3,
+  role: Group
+};
+const getFindWidgetVirtualDom = (matchCountText, replaceExpanded, findButtons, findFieldButtons, replaceButtons, replaceFieldButtons, matchCount, value) => {
+  return [parentNode, ...getResizerVirtualDom(), ...getSearchToggleButtonVirtualDom(replaceExpanded, 'handleClickToggleReplace'), {
     type: Div,
     className: FindWidgetRight,
     childCount: replaceExpanded ? 2 : 1
-  });
-  dom.push(...getFindWidgetFindVirtualDom(matchCountText, findButtons, matchCount, value));
-  if (replaceExpanded) {
-    dom.push(...getFindWidgetReplaceVirtualDom(replaceExpanded, replaceButtons));
-  }
-  return dom;
+  }, ...getFindWidgetFindVirtualDom(matchCountText, findButtons, findFieldButtons, matchCount, value), ...getFindWidgetReplaceVirtualDom(replaceExpanded, replaceButtons)];
 };
 
 const getMatchCountText = (matchIndex, matchCount) => {
@@ -1668,21 +2277,47 @@ const getMatchCountText = (matchIndex, matchCount) => {
 
 const renderContent = (oldState, newState) => {
   const {
-    uid
+    uid,
+    matchCount,
+    value,
+    replaceExpanded,
+    matchCase,
+    matchWholeWord,
+    useRegularExpression,
+    preserveCase
   } = newState;
   const matchCountText = getMatchCountText(newState.matchIndex, newState.matchCount);
   const {
     findButtonsEnabled,
     replaceButtonsEnabled
-  } = getFindWidgetButtonsEnabled(newState.matchCount, newState.value);
+  } = getFindWidgetButtonsEnabled(matchCount, value);
   const {
     findButtons,
-    replaceButtons
-  } = getFindWidgetButtons(findButtonsEnabled, replaceButtonsEnabled);
-  const dom = getFindWidgetVirtualDom(matchCountText, newState.replaceExpanded, findButtons, replaceButtons, newState.matchCase, newState.matchWholeWord, newState.useRegularExpression, newState.matchCount, newState.value);
+    replaceButtons,
+    findFieldButtons,
+    replaceFieldButtons
+  } = getFindWidgetButtons(findButtonsEnabled, replaceButtonsEnabled, matchCase, matchWholeWord, useRegularExpression, preserveCase);
+  const dom = getFindWidgetVirtualDom(matchCountText, replaceExpanded, findButtons, findFieldButtons, replaceButtons, replaceFieldButtons, matchCount, value);
   return [SetDom2, uid, dom];
 };
 
+const renderCss = (oldState, newState) => {
+  const {
+    uid,
+    width,
+    height,
+    x,
+    y
+  } = newState;
+  const css = `:root {
+    --FindWidgetWidth: ${width}px;
+    --FindWidgetHeight: ${height}px;
+    --FindWidgetX: ${x}px;
+    --FindWidgetY: ${y}px;
+  }`;
+  return [SetCss, uid, css];
+};
+
 const getEventListeners = (uid, widgetId) => {
   return [{
     name: HandleInput,
@@ -1723,6 +2358,19 @@ const getEventListeners = (uid, widgetId) => {
   }, {
     name: HandleClickReplaceAll,
     params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickReplaceAll', 0, widgetId]
+  }, {
+    name: HandleClickButton,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickButton', 0, widgetId, TargetName]
+  }, {
+    name: HandleResizerPointerDown,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleResizerPointerDown', 0, widgetId, ClientX, ClientY],
+    trackPointerEvents: [HandleResizerPointerMove, HandleResizerPointerUp]
+  }, {
+    name: HandleResizerPointerMove,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleResizerPointerMove', 0, widgetId, ClientX, ClientY]
+  }, {
+    name: HandleResizerPointerUp,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleResizerPointerUp', 0, widgetId, ClientX, ClientY]
   }];
 };
 
@@ -1736,17 +2384,53 @@ const renderEventListeners = state => {
   return [SetEventListeners, uid, eventListeners];
 };
 
+const getFocusSelector = focusKey => {
+  switch (focusKey) {
+    case FocusSearchInput:
+      return SearchValue;
+    case FocusSearchReplaceInput:
+      return ReplaceValue;
+    case FocusSearchMatchCase:
+      return MatchCase$2;
+    case FocusSearchPreserveCase:
+      return PreserveCase$1;
+    case FocusSearchRegex:
+      return UseRegularExpression$2;
+    case FocusSearchWholeWord:
+      return MatchWholeWord$2;
+    case FocusSearchReplaceAll:
+      return ReplaceAll$2;
+    case FocusToggleReplace:
+      return ToggleReplace$1;
+    case FocusFindWidgetCloseButton$1:
+      return Close$2;
+    default:
+      return '';
+  }
+};
+
 const renderFocus = (oldState, newState) => {
   const {
-    uid
+    uid,
+    focus
   } = newState;
-  return [/* method */'Viewlet.focusSelector', uid, `[name="search-value"]`];
+  const name = getFocusSelector(focus);
+  const selector = `[name="${name}"]`;
+  return [FocusSelector, uid, selector];
 };
 
 const FocusFindWidget = 16;
 
 const renderFocusContext = (oldState, newState) => {
-  return [/* method */'Viewlet.setFocusContext', FocusFindWidget];
+  return [/* method */SetFocusContext, FocusFindWidget];
+};
+
+const renderReplaceValue = (oldState, newState) => {
+  const {
+    uid,
+    replacement
+  } = newState;
+  return [SetValueByName, uid, Replace$2, replacement];
 };
 
 const renderUid = (oldState, newState) => {
@@ -1762,7 +2446,7 @@ const renderValue = (oldState, newState) => {
     uid,
     value
   } = newState;
-  return [/* method */'Viewlet.setValueByName', uid, SearchValue, value];
+  return [SetValueByName, uid, SearchValue, value];
 };
 
 const getRenderer = diffType => {
@@ -1781,6 +2465,10 @@ const getRenderer = diffType => {
       return renderFocus;
     case RenderValue:
       return renderValue;
+    case RenderReplaceValue:
+      return renderReplaceValue;
+    case RenderCss:
+      return renderCss;
     default:
       throw new Error('unknown renderer');
   }
@@ -1800,39 +2488,76 @@ const render2 = (uid, diffResult) => {
     oldState,
     newState
   } = get$1(uid);
-  set$1(uid, newState, newState);
+  set$3(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
 
-const terminate = () => {
-  globalThis.close();
+const resize = async (state, dimensions) => {
+  return state;
+};
+
+const saveState = state => {
+  const {
+    width,
+    value,
+    replacement,
+    matchCase,
+    matchWholeWord,
+    useRegularExpression,
+    replaceExpanded
+  } = state;
+  return {
+    width,
+    value,
+    replacement,
+    matchCase,
+    matchWholeWord,
+    useRegularExpression,
+    replaceExpanded
+  };
 };
 
 const commandMap = {
   'FindWidget.create': create$1,
   'FindWidget.diff2': diff2,
-  'FindWidget.dispose': dispose,
+  'FindWidget.dispose': dispose$1,
   'FindWidget.focusCloseButton': wrapCommand(focusCloseButton),
   'FindWidget.focusFirst': wrapCommand(focusFirst),
+  'FindWidget.focusElement': wrapCommand(focusElement),
   'FindWidget.focusIndex': wrapCommand(focusIndex),
   'FindWidget.focusLast': wrapCommand(focusLast),
   'FindWidget.focusNext': wrapCommand(focusNext),
   'FindWidget.focusPrevious': wrapCommand(focusPrevious),
+  'FindWidget.focusNextElement': wrapCommand(focusNextElement),
+  'FindWidget.focusPreviousElement': wrapCommand(focusPreviousElement),
   'FindWidget.focusReplace': wrapCommand(focusReplace),
   'FindWidget.focusReplaceAllButton': wrapCommand(focusReplaceAllButton),
   'FindWidget.getCommandIds': getCommandIds,
   'FindWidget.handleBlur': wrapCommand(handleBlur),
+  'FindWidget.handleClickButton': wrapCommand(handleClickButton),
   'FindWidget.handleClickClose': wrapCommand(handleClickClose),
   'FindWidget.handleInput': wrapCommand(handleInput),
+  'FindWidget.handleReplaceFocus': wrapCommand(handleReplaceFocus),
+  'FindWidget.handleReplaceInput': wrapCommand(handleReplaceInput),
+  'FindWidget.handleResizerPointerDown': wrapCommand(handleResizerPointerDown),
+  'FindWidget.handleResizerPointerMove': wrapCommand(handleResizerPointerMove),
+  'FindWidget.handleResizerPointerUp': wrapCommand(handleResizerPointerUp),
   'FindWidget.loadContent': wrapCommand(loadContent),
   'FindWidget.preventDefaultBrowserFind': wrapCommand(preventDefaultBrowserFind),
   'FindWidget.render2': render2,
+  'FindWidget.replace': wrapCommand(replace$1),
+  'FindWidget.replaceAll': wrapCommand(replaceAll$1),
+  'FindWidget.resize': wrapCommand(resize),
   'FindWidget.terminate': terminate,
-  'FindWidget.toggleReplace': wrapCommand(toggleReplace)
+  'FindWidget.saveState': wrapGetter(saveState),
+  'FindWidget.toggleMatchCase': wrapCommand(toggleMatchCase),
+  'FindWidget.toggleReplace': wrapCommand(toggleReplace$1),
+  'FindWidget.toggleUseRegularExpression': wrapCommand(toggleUseRegularExpression)
 };
 
 const listen = async () => {
+  registerCommands(commandMap);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });