@lvce-editor/static-server 0.52.8 → 0.52.10

package/static/{ae1f2a1 → 31f9f25}/packages/find-widget-worker/dist/findWidgetWorkerMain.js

@@ -378,26 +378,26 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$1 = (id, fn) => {
+const set$2 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$1 = id => {
+const get$2 = id => {
   return callbacks[id];
 };
 const remove = id => {
   delete callbacks[id];
 };
 let id = 0;
-const create$3 = () => {
+const create$3$1 = () => {
   return ++id;
 };
 const registerPromise = () => {
-  const id = create$3();
+  const id = create$3$1();
   const {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$1(id, resolve);
+  set$2(id, resolve);
   return {
     id,
     promise
@@ -554,7 +554,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$1(id);
+  const fn = get$2(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -708,7 +708,7 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke = (ipc, method, ...params) => {
+const invoke$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer = (ipc, method, ...params) => {
@@ -741,7 +741,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
+      return invoke$1(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer(ipc, method, ...params);
@@ -782,7 +782,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$2 = async ({
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -794,10 +794,10 @@ const create$2 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$2
+  create: create$3
 };
 
-const create$1 = () => {
+const create$2 = () => {
   const states = Object.create(null);
   return {
     get(uid) {
@@ -857,14 +857,16 @@ const create$1 = () => {
 };
 
 const {
-  get,
-  set,
-  wrapCommand
-} = create$1();
+  get: get$1,
+  set: set$1,
+  wrapCommand,
+  dispose: dispose$1
+} = create$2();
 
+const Script$1 = 2;
 const Unknown = 0;
 
-const create = (uid, x, y, width, height, parentUid) => {
+const create$1 = (uid, x, y, width, height, parentUid) => {
   const state = {
     uid,
     value: '',
@@ -877,7 +879,7 @@ const create = (uid, x, y, width, height, parentUid) => {
     matchCase: false,
     matchWholeWord: false,
     replacement: '',
-    editorUid: 0,
+    editorUid: parentUid,
     x: 0,
     y: 0,
     width: 0,
@@ -885,14 +887,56 @@ const create = (uid, x, y, width, height, parentUid) => {
     focused: false,
     focusSource: Unknown,
     focus: 0,
-    version: 0
+    version: 0,
+    lines: [],
+    selections: [],
+    editorX: x,
+    editorY: y,
+    editorWidth: width,
+    editorHeight: height,
+    inputSource: 0
   };
-  set(uid, state, state);
+  set$1(uid, state, state);
   return state;
 };
 
-const modules = [];
-const numbers = [];
+const isEqual$5 = (oldState, newState) => {
+  return oldState.x === newState.x && oldState.y === newState.y && oldState.width === newState.width && oldState.height === newState.height;
+};
+
+const isEqual$4 = (oldState, newState) => {
+  return oldState.version === newState.version;
+};
+
+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;
+};
+
+const isEqual$1 = (oldState, newState) => {
+  return oldState.version === newState.version;
+};
+
+const RenderBounds = 8;
+const RenderEventListeners = 11;
+const RenderUid = 12;
+const RenderContent = 13;
+const RenderFocusContext = 14;
+const RenderFocus = 15;
+const RenderValue = 16;
+
+const Script = 1;
+const User = 2;
+
+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 diff = (oldState, newState) => {
   const diffResult = [];
@@ -909,34 +953,371 @@ const diff2 = uid => {
   const {
     oldState,
     newState
-  } = get(uid);
+  } = get$1(uid);
   const diffResult = diff(oldState, newState);
   return diffResult;
 };
 
+const dispose = uid => {
+  return dispose$1(uid);
+};
+
+const FocusFindWidgetCloseButton = 48;
+const FocusFindWidgetReplace = 43;
+const FocusFindWidgetReplaceAllButton = 47;
+
+const setFindWidgetFocus = (state, focusKey) => {
+  if (state.focus === focusKey) {
+    return state;
+  }
+  return {
+    ...state,
+    focus: focusKey,
+    focusSource: Script$1
+  };
+};
+
+const focusCloseButton = state => {
+  return setFindWidgetFocus(state, FocusFindWidgetCloseButton);
+};
+
+// TODO don't call renderer worker, set editor state
+// TODO this function should be synchronous
+const focusIndex = (state, index) => {
+  const {
+    matchIndex
+  } = state;
+  if (index === matchIndex) {
+    return state;
+  }
+  // TODO update editor
+  // const { widgets } = editor
+  // const childIndex = widgets.findIndex(isFind)
+  // const childWidget = widgets[childIndex]
+
+  // // TODO find next match and highlight it
+  // const matchRowIndex = matches[index * 2]
+  // const matchColumnIndex = matches[index * 2 + 1]
+  // const newSelections = new Uint32Array([matchRowIndex, matchColumnIndex, matchRowIndex, matchColumnIndex + value.length])
+  // const newState: FindWidgetState = {
+  //   ...findState,
+  //   matchIndex: index,
+  // }
+  // const newWidget = {
+  //   ...childWidget,
+  //   newState,
+  // }
+  // const newWidgets = [...widgets.slice(0, childIndex), newWidget, ...widgets.slice(childIndex + 1)]
+  return {
+    ...state,
+    matchIndex: index
+  };
+};
+const focusFirst = state => {
+  return focusIndex(state, 0);
+};
+const focusLast = state => {
+  const {
+    matchCount
+  } = state;
+  return focusIndex(state, matchCount - 1);
+};
+const focusNext = state => {
+  const {
+    matchIndex,
+    matchCount
+  } = state;
+  if (matchIndex === matchCount - 1) {
+    return focusFirst(state);
+  }
+  return focusIndex(state, matchIndex + 1);
+};
+const focusPrevious = state => {
+  const {
+    matchIndex
+  } = state;
+  if (matchIndex === 0) {
+    return focusLast(state);
+  }
+  return focusIndex(state, matchIndex - 1);
+};
+
+const focusReplace = state => {
+  return setFindWidgetFocus(state, FocusFindWidgetReplace);
+};
+
+const focusReplaceAllButton = state => {
+  return setFindWidgetFocus(state, FocusFindWidgetReplaceAllButton);
+};
+
+const handleBlur = async state => {
+  return {
+    ...state,
+    focus: 0,
+    focused: false
+  };
+};
+
+const rpcs = Object.create(null);
+const set$a = (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
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$a(rpcId, rpc);
+    }
+  };
+};
+const EditorWorker$1 = 99;
+const {
+  invoke: invoke$9,
+  set: set$9
+} = create(EditorWorker$1);
+const EditorWorker = {
+  __proto__: null,
+  invoke: invoke$9,
+  set: set$9
+};
+
+const {
+  invoke,
+  set} = EditorWorker;
+
+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 findRegexMatches = (lines, regex) => {
+  if (!regex.global) {
+    throw new Error('regex must be global');
+  }
+  const {
+    length
+  } = lines;
+  const matches = [];
+  for (let i = 0; i < length; i++) {
+    const line = lines[i];
+    let lastMatch;
+    do {
+      lastMatch = regex.exec(line);
+      if (!lastMatch) {
+        break;
+      }
+      matches.push(i, lastMatch.index);
+    } while (true);
+  }
+  return new Uint32Array(matches);
+};
+
+// copied from https://github.com/microsoft/vscode/tree/main/src/vs/base/common/strings.ts by Microsoft (License MIT)
+
+const RE_ESCAPE = /[\\\{\}\*\+\?\|\^\$\.\[\]\(\)]/g;
+const escapeRegExpCharacters = value => {
+  return value.replaceAll(RE_ESCAPE, String.raw`\$&`);
+};
+
+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 getMatchCount = matches => {
+  return matches.length / 2;
+};
+
+const refresh$1 = (state, value) => {
+  const {
+    lines
+  } = state;
+  const matches = findMatchesCaseInsensitive(lines, value);
+  const matchCount = getMatchCount(matches);
+  return {
+    ...state,
+    matches,
+    matchIndex: 0,
+    matchCount,
+    value,
+    inputSource: User
+  };
+};
+
+const refresh = (state, value = state.value) => {
+  return refresh$1(state, value);
+};
+
+const handleInput = (state, value) => {
+  return refresh(state, value);
+};
+
+const getFindWidgetHeight = replaceExpanded => {
+  const collapsedHeight = 30;
+  const expandedHeight = 60;
+  const newHeight = replaceExpanded ? expandedHeight : collapsedHeight;
+  return newHeight;
+};
+
+const toggleReplace = state => {
+  const {
+    replaceExpanded
+  } = state;
+  const newExpanded = !replaceExpanded;
+  const newHeight = getFindWidgetHeight(newExpanded);
+  return {
+    ...state,
+    replaceExpanded: newExpanded,
+    height: newHeight
+  };
+};
+
 const commandIds = ['handleSliderPointerDown', 'handleSliderPointerMove'];
 
 const getCommandIds = () => {
   return commandIds;
 };
 
-const loadContent = state => {
+const getFindWidgetPosition = (editorX, editorY, editorWidth) => {
+  const width = 300;
+  const height = 30;
+  const paddingTop = 10;
+  const paddingRight = 20;
+  const x = editorX + editorWidth - width - paddingRight;
+  const y = editorY + paddingTop;
+  return {
+    y,
+    x,
+    width,
+    height
+  };
+};
+
+const getLines = async editorUid => {
+  // @ts-ignore
+  const lines = await invoke('Editor.getLines2', editorUid);
+  // @ts-ignore
+  return lines;
+};
+
+const getSelectedText = (lines, selections) => {
+  const startRowIndex = selections[0];
+  const startColumnIndex = selections[1];
+  const endColumnIndex = selections[3];
+  const line = lines[startRowIndex];
+  const value = line.slice(startColumnIndex, endColumnIndex);
+  return value;
+};
+
+const getSelections = async editorUid => {
+  // @ts-ignore
+  const selections = await invoke('Editor.getSelections2', editorUid);
+  // @ts-ignore
+  return selections;
+};
+
+const loadContent = async state => {
+  const {
+    editorUid,
+    editorWidth,
+    editorX,
+    editorY
+  } = state;
+  const lines = await getLines(editorUid);
+  const selections = await getSelections(editorUid);
+  const {
+    x,
+    y,
+    width,
+    height
+  } = getFindWidgetPosition(editorX, editorY, editorWidth);
+  if (lines.length === 0) {
+    return state;
+  }
+  const value = getSelectedText(lines, selections);
+  const matches = findMatchesCaseInsensitive(lines, value);
+  const matchCount = getMatchCount(matches);
   return {
     ...state,
-    version: 1
+    value,
+    matches,
+    matchIndex: 0,
+    matchCount,
+    version: 1,
+    x,
+    y,
+    width,
+    height,
+    lines,
+    selections,
+    focused: true,
+    inputSource: Script
   };
 };
 
-const RenderContent = 13;
+const SetBounds = 'Viewlet.setBounds';
+const SetDom2 = 'Viewlet.setDom2';
+const SetUid = 'Viewlet.setUid';
+const SetEventListeners = 'Viewlet.registerEventListeners';
+
+const renderBounds = (oldState, newState) => {
+  const {
+    x,
+    y,
+    width,
+    height,
+    uid
+  } = newState;
+  return [SetBounds, uid, x, y, width, height];
+};
 
+const HandleBlur = 'handleBlur';
 const HandleClickClose = 'handleClickClose';
+const HandleClickFocusPreviousMatch = 'handleClickFocusPreviousMatch';
 const HandleClickNextMatch = 'handleClickNextMatch';
 const HandleClickPreviousMatch = 'handleClickPreviousMatch';
 const HandleClickReplace = 'handleClickReplace';
+const HandleClickToggleReplace = 'handleClickToggleReplace';
 const HandleClickReplaceAll = 'handleClickReplaceAll';
 const HandleFocus = 'handleFocus';
 const HandleInput = 'handleInput';
 const HandleReplaceFocus = 'handleReplaceFocus';
+const HandleFocusPrevious = 'handleFocusPrevious';
+const HandleFocusNext = 'handleFocusNext';
 const HandleReplaceInput = 'handleReplaceInput';
 
 const emptyObject = {};
@@ -951,45 +1332,41 @@ const i18nString = (key, placeholders = emptyObject) => {
   return key.replaceAll(RE_PLACEHOLDER, replacer);
 };
 
-/**
- * @enum {string}
- */
-const UiStrings = {
-  MatchOf: '{PH1} of {PH2}',
-  NoResults: 'No Results',
-  Close: 'Close',
-  PreviousMatch: 'Previous Match',
-  NextMatch: 'Next Match',
-  Find: 'Find',
-  Replace: 'Replace',
-  ReplaceAll: 'Replace All'
-};
+const MatchOf = '{PH1} of {PH2}';
+const NoResults = 'No Results';
+const Close$2 = 'Close';
+const PreviousMatch = 'Previous Match';
+const NextMatch = 'Next Match';
+const Find$1 = 'Find';
+const Replace$2 = 'Replace';
+const ReplaceAll$2 = 'Replace All';
+
 const noResults = () => {
-  return i18nString(UiStrings.NoResults);
+  return i18nString(NoResults);
 };
 const matchOf = (matchIndex, matchCount) => {
-  return i18nString(UiStrings.MatchOf, {
+  return i18nString(MatchOf, {
     PH1: matchIndex,
     PH2: matchCount
   });
 };
 const previousMatch = () => {
-  return i18nString(UiStrings.PreviousMatch);
+  return i18nString(PreviousMatch);
 };
 const nextMatch = () => {
-  return i18nString(UiStrings.NextMatch);
+  return i18nString(NextMatch);
 };
 const close = () => {
-  return i18nString(UiStrings.Close);
+  return i18nString(Close$2);
 };
 const find = () => {
-  return i18nString(UiStrings.Find);
+  return i18nString(Find$1);
 };
 const replace = () => {
-  return i18nString(UiStrings.Replace);
+  return i18nString(Replace$2);
 };
 const replaceAll = () => {
-  return i18nString(UiStrings.ReplaceAll);
+  return i18nString(ReplaceAll$2);
 };
 
 const ArrowDown = 'ArrowDown';
@@ -998,6 +1375,9 @@ 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';
@@ -1069,6 +1449,10 @@ const SearchField = 'SearchField';
 const SearchFieldButton = 'SearchFieldButton';
 const SearchFieldButtonChecked = 'SearchFieldButtonChecked';
 const SearchFieldButtons = 'SearchFieldButtons';
+const Viewlet = 'Viewlet';
+const ViewletFind = 'ViewletFind';
+const FindWidget = 'FindWidget';
+const ViewletFindWidget = 'ViewletFindWidget';
 
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
@@ -1199,13 +1583,11 @@ const getFindWidgetReplaceVirtualDom = (replaceExpanded, replaceButtons) => {
       type: Div,
       className: FindWidgetReplace,
       childCount: 1 + replaceButtons.length
-    }, ...getSearchFieldVirtualDom('replace-value', replace(), HandleReplaceInput, [], [], HandleReplaceFocus), ...replaceButtons.flatMap(getIconButtonVirtualDom));
+    }, ...getSearchFieldVirtualDom(ReplaceValue, replace(), HandleReplaceInput, [], [], HandleReplaceFocus), ...replaceButtons.flatMap(getIconButtonVirtualDom));
   }
   return dom;
 };
 
-const ToggleReplace = 'ToggleReplace';
-
 const getSearchToggleButtonVirtualDom = (replaceExpanded, onClick = '') => {
   return [{
     type: Button,
@@ -1229,7 +1611,7 @@ const getFindWidgetVirtualDom = (matchCountText, replaceExpanded, findButtons, r
   const dom = [];
   dom.push({
     type: Div,
-    className: 'Viewlet ViewletFind ViewletFindWidget FindWidget',
+    className: mergeClassNames(Viewlet, ViewletFind, ViewletFindWidget, FindWidget),
     childCount: 2,
     role: Group
   });
@@ -1253,8 +1635,6 @@ const getMatchCountText = (matchIndex, matchCount) => {
   return matchOf(matchIndex + 1, matchCount);
 };
 
-const SetDom2 = 'Viewlet.setDom2';
-
 const renderContent = (oldState, newState) => {
   const {
     uid
@@ -1272,10 +1652,104 @@ const renderContent = (oldState, newState) => {
   return [SetDom2, uid, dom];
 };
 
+const getEventListeners = (uid, widgetId) => {
+  return [{
+    name: HandleInput,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleInput', 0, widgetId, 'event.target.value']
+  }, {
+    name: HandleClickClose,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickClose', 0, widgetId]
+  }, {
+    name: HandleClickFocusPreviousMatch,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickPreviousMatch', 0, widgetId]
+  }, {
+    name: HandleClickNextMatch,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickNextMatch', 0, widgetId]
+  }, {
+    name: HandleClickReplace,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickReplace', 0, widgetId]
+  }, {
+    name: HandleClickReplace,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickReplaceAll', 0, widgetId]
+  }, {
+    name: HandleClickToggleReplace,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.toggleReplace', 0, widgetId]
+  }, {
+    name: HandleBlur,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleBlur', 0, widgetId]
+  }, {
+    name: HandleReplaceInput,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleReplaceInput', 0, widgetId]
+  }, {
+    name: HandleReplaceFocus,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleReplaceFocus', 0, widgetId]
+  }, {
+    name: HandleFocusPrevious,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleFocusPrevious', 0, widgetId]
+  }, {
+    name: HandleFocusNext,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleFocusNext', 0, widgetId]
+  }, {
+    name: HandleClickReplaceAll,
+    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickReplaceAll', 0, widgetId]
+  }];
+};
+
+const Find = 5;
+
+const renderEventListeners = state => {
+  const {
+    uid
+  } = state;
+  const eventListeners = getEventListeners(uid, Find);
+  return [SetEventListeners, uid, eventListeners];
+};
+
+const renderFocus = (oldState, newState) => {
+  const {
+    uid
+  } = newState;
+  return [/* method */'Viewlet.focusSelector', uid, `[name="search-value"]`];
+};
+
+const FocusFindWidget = 16;
+
+const renderFocusContext = (oldState, newState) => {
+  return [/* method */'Viewlet.setFocusContext', FocusFindWidget];
+};
+
+const renderUid = (oldState, newState) => {
+  const {
+    uid,
+    editorUid
+  } = newState;
+  return [SetUid, uid, editorUid];
+};
+
+const renderValue = (oldState, newState) => {
+  const {
+    uid,
+    value
+  } = newState;
+  return [/* method */'Viewlet.setValueByName', uid, SearchValue, value];
+};
+
 const getRenderer = diffType => {
   switch (diffType) {
     case RenderContent:
       return renderContent;
+    case RenderBounds:
+      return renderBounds;
+    case RenderEventListeners:
+      return renderEventListeners;
+    case RenderUid:
+      return renderUid;
+    case RenderFocusContext:
+      return renderFocusContext;
+    case RenderFocus:
+      return renderFocus;
+    case RenderValue:
+      return renderValue;
     default:
       throw new Error('unknown renderer');
   }
@@ -1294,8 +1768,8 @@ const render2 = (uid, diffResult) => {
   const {
     oldState,
     newState
-  } = get(uid);
-  set(uid, newState, newState);
+  } = get$1(uid);
+  set$1(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -1305,26 +1779,32 @@ const terminate = () => {
 };
 
 const commandMap = {
-  'ColorPicker.create': create,
-  'ColorPicker.diff2': diff2,
-  'ColorPicker.getCommandIds': getCommandIds,
-  'ColorPicker.loadContent': wrapCommand(loadContent),
-  'ColorPicker.render2': render2,
-  'ColorPicker.terminate': terminate
-};
-
-const RendererWorker = 1;
-
-const rpcs = Object.create(null);
-const set$6 = (id, rpc) => {
-  rpcs[id] = rpc;
+  'FindWidget.create': create$1,
+  'FindWidget.diff2': diff2,
+  'FindWidget.dispose': dispose,
+  'FindWidget.focusCloseButton': wrapCommand(focusCloseButton),
+  'FindWidget.focusFirst': wrapCommand(focusFirst),
+  'FindWidget.focusIndex': wrapCommand(focusIndex),
+  'FindWidget.focusLast': wrapCommand(focusLast),
+  'FindWidget.focusNext': wrapCommand(focusNext),
+  'FindWidget.focusPrevious': wrapCommand(focusPrevious),
+  'FindWidget.focusReplace': wrapCommand(focusReplace),
+  'FindWidget.focusReplaceAllButton': wrapCommand(focusReplaceAllButton),
+  'FindWidget.getCommandIds': getCommandIds,
+  'FindWidget.handleBlur': wrapCommand(handleBlur),
+  'FindWidget.handleClickClose': wrapCommand(handleClickClose),
+  'FindWidget.handleInput': wrapCommand(handleInput),
+  'FindWidget.loadContent': wrapCommand(loadContent),
+  'FindWidget.render2': render2,
+  'FindWidget.terminate': terminate,
+  'FindWidget.toggleReplace': wrapCommand(toggleReplace)
 };
 
 const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$6(RendererWorker, rpc);
+  set(rpc);
 };
 
 const main = async () => {