@lvce-editor/static-server 0.59.1 → 0.59.2

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

@@ -982,30 +982,35 @@ const create$1 = (uid, x, y, width, height, parentUid) => {
     inputSource: 0,
     preserveCase: false,
     resizerPointerDown: false,
-    minWidth: 300
+    minWidth: 400,
+    history: []
   };
   set$3(uid, state, state);
   return state;
 };
 
-const isEqual$6 = (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$5 = (oldState, newState) => {
+const isEqual$6 = (oldState, newState) => {
   return newState.width === newState.width && oldState.height === newState.height && oldState.x === newState.x;
 };
 
-const isEqual$4 = (oldState, newState) => {
+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) => {
@@ -1033,9 +1038,10 @@ const TextArea = 62;
 
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
+const TargetName = 'event.target.name';
 
 const User = 1;
-const Script = 1;
+const Script = 2;
 
 const EditorWorker$1 = 99;
 
@@ -1044,11 +1050,26 @@ 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$6, isEqual$1, isEqual$3, isEqual$3, isEqual, isEqual$5];
+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) => {
@@ -1431,15 +1452,15 @@ const toggleUseRegularExpression = state => {
 const Close$2 = 'Close';
 const FocusNext = 'FocusNext';
 const FocusPrevious = 'FocusPrevious';
-const MatchCase$1 = 'MatchCase';
-const MatchWholeWord$1 = 'MatchWholeWord';
-const PreserveCase = 'PreserveCase';
+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$1 = 'UseRegularExpression';
+const UseRegularExpression$2 = 'UseRegularExpression';
 
 const applyEdits = async (editorId, edits) => {
   // @ts-ignore
@@ -1512,13 +1533,13 @@ const getClickHandler = name => {
       return replace$1;
     case ReplaceAll$2:
       return replaceAll$1;
-    case MatchCase$1:
+    case MatchCase$2:
       return toggleMatchCase;
-    case MatchWholeWord$1:
+    case MatchWholeWord$2:
       return toggleMatchWholeWord;
-    case UseRegularExpression$1:
+    case UseRegularExpression$2:
       return toggleUseRegularExpression;
-    case PreserveCase:
+    case PreserveCase$1:
       return togglePreserveCase;
     default:
       throw new Error(`unexpected click`);
@@ -1569,10 +1590,13 @@ const handleResizerPointerDown = async (state, eventX, eventY) => {
   };
 };
 
-const getNewWidth = (oldWidth, oldX, eventX, minWidth) => {
+const getNewCoordinates = (oldWidth, oldX, eventX, minWidth) => {
   const oldXEnd = oldX + oldWidth;
   const newWidth = Math.max(oldXEnd - eventX, minWidth);
-  return newWidth;
+  return {
+    newWidth,
+    newX: eventX
+  };
 };
 const handleResizerPointerMove = async (state, eventX, eventY) => {
   const {
@@ -1584,10 +1608,13 @@ const handleResizerPointerMove = async (state, eventX, eventY) => {
   if (!resizerPointerDown) {
     return state;
   }
-  const newWidth = getNewWidth(width, x, eventX, minWidth);
+  const {
+    newWidth,
+    newX
+  } = getNewCoordinates(width, x, eventX, minWidth);
   return {
     ...state,
-    x: eventX,
+    x: newX,
     width: newWidth
   };
 };
@@ -1619,6 +1646,108 @@ const toggleReplace$1 = state => {
   };
 };
 
+const focusElement = (state, whenExpression) => {
+  return {
+    ...state,
+    focus: whenExpression,
+    focusSource: Script
+  };
+};
+
+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,
@@ -1679,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 {
@@ -1697,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
   };
 };
 
@@ -1771,17 +1927,24 @@ const i18nString = (key, placeholders = emptyObject) => {
 
 const MatchOf = '{PH1} of {PH2}';
 const NoResults = 'No Results';
+const PreserveCase = 'Preserve Case';
 const Close$1 = 'Close';
 const PreviousMatch = 'Previous Match';
 const NextMatch = 'Next Match';
 const Find$1 = 'Find';
 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,
@@ -1806,6 +1969,15 @@ const replace = () => {
 const replaceAll = () => {
   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);
 };
@@ -1819,7 +1991,33 @@ const Close = 'Close';
 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,
@@ -1843,18 +2041,20 @@ const getFindWidgetButtons = (findButtonsEnabled, replaceButtonsEnabled) => {
     label: replace(),
     icon: Replace,
     disabled: !replaceButtonsEnabled,
-    onClick: HandleClickReplace,
+    onClick: HandleClickButton,
     name: Replace$2
   }, {
     label: replaceAll(),
     icon: ReplaceAll,
     disabled: !replaceButtonsEnabled,
-    onClick: HandleClickReplaceAll,
+    onClick: HandleClickButton,
     name: ReplaceAll$2
   }];
   return {
     findButtons,
-    replaceButtons
+    findFieldButtons,
+    replaceButtons,
+    replaceFieldButtons
   };
 };
 
@@ -1896,28 +2096,12 @@ const Viewlet = 'Viewlet';
 const ViewletFind = 'ViewletFind';
 const FindWidget = 'FindWidget';
 const ViewletFindWidget = 'ViewletFindWidget';
-
-const getFindButtons = () => {
-  return [{
-    checked: false,
-    icon: MatchCase,
-    title: 'Match Case',
-    name: MatchCase$1,
-    onClick: HandleClickButton
-  }, {
-    checked: false,
-    icon: MatchWholeWord,
-    title: 'Match Whole Word',
-    name: MatchWholeWord$1,
-    onClick: HandleClickButton
-  }, {
-    checked: false,
-    icon: UseRegularExpression,
-    title: 'Use Regular Expression',
-    name: UseRegularExpression$1,
-    onClick: HandleClickButton
-  }];
-};
+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) {
@@ -1929,7 +2113,7 @@ const getFindMatchCountClassName = (matchCount, value) => {
 const getIconVirtualDom = (icon, type = Div) => {
   return {
     type,
-    className: `MaskIcon MaskIcon${icon}`,
+    className: `${MaskIcon} MaskIcon${icon}`,
     role: None,
     childCount: 0
   };
@@ -1954,11 +2138,13 @@ 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,
@@ -1968,9 +2154,9 @@ const getSearchFieldButtonVirtualDom = button => {
     onClick
   } = button;
   return [{
-    type: Div,
+    type: Button,
     ariaChecked: checked,
-    className: mergeClassNames(SearchFieldButton, checked ? SearchFieldButtonChecked : ''),
+    className: checked ? checkedClassName : unCheckedClassName,
     name,
     role: CheckBox,
     tabIndex: 0,
@@ -2012,44 +2198,38 @@ 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(SearchValue, find(), HandleInput, getFindButtons(), [], 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',
+    className: Resizer,
     childCount: 1,
     onPointerDown: HandleResizerPointerDown
   }, {
     type: Div,
-    className: 'ResizerHighlight',
+    className: ResizerHighlight,
     childCount: 0
   }];
 };
@@ -2058,7 +2238,7 @@ const getSearchToggleButtonVirtualDom = (replaceExpanded, onClick = '') => {
   const title = toggleReplace();
   return [{
     type: Button,
-    className: `IconButton SearchToggleButton ${replaceExpanded ? 'SearchToggleButtonExpanded' : ''}`,
+    className: mergeClassNames(IconButton, SearchToggleButton, replaceExpanded ? SearchToggleButtonExpanded : ''),
     title,
     ariaLabel: title,
     ariaExpanded: replaceExpanded,
@@ -2069,31 +2249,23 @@ const getSearchToggleButtonVirtualDom = (replaceExpanded, onClick = '') => {
     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: 3,
-    role: Group
-  });
-  dom.push(...getResizerVirtualDom());
-  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) => {
@@ -2105,18 +2277,27 @@ 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];
 };
 
@@ -2179,7 +2360,7 @@ const getEventListeners = (uid, widgetId) => {
     params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickReplaceAll', 0, widgetId]
   }, {
     name: HandleClickButton,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickButton', 0, widgetId, `event.target.name`]
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickButton', 0, widgetId, TargetName]
   }, {
     name: HandleResizerPointerDown,
     params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleResizerPointerDown', 0, widgetId, ClientX, ClientY],
@@ -2203,11 +2384,39 @@ 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 */FocusSelector, uid, `[name="search-value"]`];
+  const name = getFocusSelector(focus);
+  const selector = `[name="${name}"]`;
+  return [FocusSelector, uid, selector];
 };
 
 const FocusFindWidget = 16;
@@ -2290,10 +2499,22 @@ const resize = async (state, dimensions) => {
 
 const saveState = state => {
   const {
-    width
+    width,
+    value,
+    replacement,
+    matchCase,
+    matchWholeWord,
+    useRegularExpression,
+    replaceExpanded
   } = state;
   return {
-    width
+    width,
+    value,
+    replacement,
+    matchCase,
+    matchWholeWord,
+    useRegularExpression,
+    replaceExpanded
   };
 };
 
@@ -2303,10 +2524,13 @@ const commandMap = {
   '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,