@lvce-editor/static-server 0.91.21 → 0.91.22

package/static/{53bd123 → 169c488}/packages/editor-worker/dist/editorWorkerMain.js

@@ -1626,6 +1626,7 @@ const Tab$1 = 2;
 const Enter = 3;
 const Escape = 8;
 const Space$1 = 9;
+const PageDown = 11;
 const End = 255;
 const Home = 12;
 const LeftArrow = 13;
@@ -1648,6 +1649,7 @@ const KeyZ = 54;
 const F2 = 58;
 const F3 = 59;
 const F4 = 60;
+const F9 = 65;
 const F12 = 68;
 const Period = 87;
 const Slash$1 = 88;
@@ -1954,6 +1956,7 @@ const createEditor2 = (id, uri, x, y, width, height, platform, assetDir) => {
   const editor = {
     additionalFocus: 0,
     assetDir,
+    breakPoints: [],
     charWidth: 0,
     columnWidth: 0,
     completionState: '',
@@ -1974,6 +1977,7 @@ const createEditor2 = (id, uri, x, y, width, height, platform, assetDir) => {
     focus: 0,
     focused: false,
     focusKey: Empty,
+    foldingRanges: [],
     fontFamily: '',
     fontSize: 0,
     fontWeight: 0,
@@ -2029,6 +2033,7 @@ const createEditor2 = (id, uri, x, y, width, height, platform, assetDir) => {
     undoStack: [],
     uri,
     validLines: [],
+    visibleLineIndices: [],
     visualDecorations: [],
     widgets: [],
     width,
@@ -2105,6 +2110,234 @@ const clamp = (num, min, max) => {
   return Math.min(Math.max(num, min), max);
 };
 
+const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
+  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
+  if (!Number.isFinite(scrollBarOffset)) {
+    return 0;
+  }
+  return scrollBarOffset;
+};
+const getScrollBarY = getScrollBarOffset;
+
+const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
+  if (size >= contentSize) {
+    return 0;
+  }
+  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
+};
+
+const getScrollBarWidth = (width, longestLineWidth) => {
+  if (width > longestLineWidth) {
+    return 0;
+  }
+  return width ** 2 / longestLineWidth;
+};
+
+const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
+  const halfScrollBarHeight = scrollBarHeight / 2;
+  if (relativeY <= halfScrollBarHeight) {
+    // clicked at top
+    return {
+      handleOffset: relativeY,
+      percent: 0
+    };
+  }
+  if (relativeY <= height - halfScrollBarHeight) {
+    // clicked in middle
+    return {
+      handleOffset: halfScrollBarHeight,
+      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight)
+    };
+  }
+  // clicked at bottom
+  return {
+    handleOffset: scrollBarHeight - height + relativeY,
+    percent: 1
+  };
+};
+
+const getSortedRanges = ranges => {
+  return ranges.toSorted((a, b) => a.start - b.start || b.end - a.end);
+};
+const getUnhiddenRow = (rowIndex, previousRowIndex, lineCount, ranges) => {
+  for (const range of ranges) {
+    if (rowIndex > range.start && rowIndex <= range.end) {
+      return rowIndex >= previousRowIndex ? Math.min(range.end + 1, lineCount - 1) : range.start;
+    }
+  }
+  return rowIndex;
+};
+const getVisibleLineCount = (lineCount, ranges) => {
+  let hidden = 0;
+  let hiddenUntil = -1;
+  for (const range of getSortedRanges(ranges)) {
+    const start = Math.max(range.start + 1, hiddenUntil + 1);
+    const end = Math.min(range.end, lineCount - 1);
+    if (start <= end) {
+      hidden += end - start + 1;
+      hiddenUntil = end;
+    }
+  }
+  return lineCount - hidden;
+};
+const getVisualRowForDocumentRow = (rowIndex, ranges) => {
+  let hiddenBefore = 0;
+  for (const range of getSortedRanges(ranges)) {
+    if (rowIndex <= range.start) {
+      break;
+    }
+    if (rowIndex <= range.end) {
+      return range.start - hiddenBefore;
+    }
+    hiddenBefore += range.end - range.start;
+  }
+  return rowIndex - hiddenBefore;
+};
+const getDocumentRowForVisualRow = (visualRow, ranges) => {
+  let documentRow = visualRow;
+  let hiddenBefore = 0;
+  for (const range of getSortedRanges(ranges)) {
+    const rangeVisualRow = range.start - hiddenBefore;
+    if (visualRow <= rangeVisualRow) {
+      break;
+    }
+    const hiddenCount = range.end - range.start;
+    documentRow += hiddenCount;
+    hiddenBefore += hiddenCount;
+  }
+  return documentRow;
+};
+const getViewportLineIndices = (lineCount, ranges, startVisualRow, numberOfVisibleLines) => {
+  const visibleLineCount = getVisibleLineCount(lineCount, ranges);
+  const endVisualRow = Math.min(startVisualRow + numberOfVisibleLines, visibleLineCount);
+  const result = [];
+  for (let visualRow = startVisualRow; visualRow < endVisualRow; visualRow++) {
+    result.push(getDocumentRowForVisualRow(visualRow, ranges));
+  }
+  return result;
+};
+const updateLayout = (editor, foldingRanges) => {
+  const {
+    height,
+    itemHeight,
+    lines,
+    minimumSliderSize,
+    numberOfVisibleLines,
+    rowHeight
+  } = editor;
+  const visibleLineCount = getVisibleLineCount(lines.length, foldingRanges);
+  const finalY = Math.max(visibleLineCount - numberOfVisibleLines, 0);
+  const finalDeltaY = finalY * itemHeight;
+  const deltaY = clamp(editor.deltaY, 0, finalDeltaY);
+  const startVisualRow = Math.floor(deltaY / itemHeight);
+  const visibleLineIndices = getViewportLineIndices(lines.length, foldingRanges, startVisualRow, numberOfVisibleLines);
+  const minLineY = visibleLineIndices[0] ?? 0;
+  const maxLineY = visibleLineIndices.length === 0 ? 0 : visibleLineIndices.at(-1) + 1;
+  const contentHeight = visibleLineCount * rowHeight;
+  const scrollBarHeight = getScrollBarSize(height, contentHeight, minimumSliderSize);
+  const scrollBarY = getScrollBarY(deltaY, finalDeltaY, height, scrollBarHeight);
+  return {
+    ...editor,
+    deltaY,
+    finalDeltaY,
+    finalY,
+    foldingRanges,
+    maxLineY,
+    minLineY,
+    scrollBarHeight,
+    scrollBarY,
+    visibleLineIndices
+  };
+};
+const addRange = (ranges, range) => {
+  if (ranges.some(existing => existing.start <= range.start && existing.end >= range.end)) {
+    return ranges;
+  }
+  const remainingRanges = ranges.filter(existing => range.start > existing.start || range.end < existing.end);
+  return getSortedRanges([...remainingRanges, range]);
+};
+const removeRangeAt = (ranges, rowIndex) => {
+  let bestIndex = -1;
+  let bestSize = Infinity;
+  for (let i = 0; i < ranges.length; i++) {
+    if (ranges[i].start === rowIndex) {
+      bestIndex = i;
+      break;
+    }
+    const range = ranges[i];
+    if (rowIndex >= range.start && rowIndex <= range.end && range.end - range.start < bestSize) {
+      bestIndex = i;
+      bestSize = range.end - range.start;
+    }
+  }
+  return bestIndex === -1 ? ranges : ranges.filter((_, index) => index !== bestIndex);
+};
+const scanLine = (line, row, stack, ranges, state) => {
+  for (let column = 0; column < line.length; column++) {
+    const character = line[column];
+    const next = line[column + 1];
+    if (state.blockComment) {
+      if (character === '*' && next === '/') {
+        state.blockComment = false;
+        column++;
+      }
+      continue;
+    }
+    if (state.quote) {
+      if (state.escaped) {
+        state.escaped = false;
+      } else if (character === '\\') {
+        state.escaped = true;
+      } else if (character === state.quote) {
+        state.quote = '';
+      }
+      continue;
+    }
+    if (character === '/' && next === '/') {
+      return;
+    }
+    if (character === '/' && next === '*') {
+      state.blockComment = true;
+      column++;
+      continue;
+    }
+    if (["'", '"', '`'].includes(character)) {
+      state.quote = character;
+      continue;
+    }
+    if (character === '{') {
+      stack.push(row);
+      continue;
+    }
+    if (character === '}') {
+      const start = stack.pop();
+      if (start !== undefined && start < row) {
+        ranges.push({
+          end: row,
+          start
+        });
+      }
+    }
+  }
+  if (state.quote !== '`') {
+    state.quote = '';
+    state.escaped = false;
+  }
+};
+const findRange = (lines, rowIndex) => {
+  const stack = [];
+  const ranges = [];
+  const state = {
+    blockComment: false,
+    escaped: false,
+    quote: ''
+  };
+  for (let row = 0; row < lines.length; row++) {
+    scanLine(lines[row], row, stack, ranges, state);
+  }
+  return ranges.filter(range => range.start <= rowIndex && rowIndex <= range.end).toSorted((a, b) => a.end - a.start - (b.end - b.start))[0];
+};
+
 const Link$1 = 'Link';
 const EditorGoToDefinitionLink = 'EditorGoToDefinitionLink';
 const Function = 'Function';
@@ -3089,11 +3322,19 @@ const getVisible$1 = async (editor, syncIncremental) => {
     charWidth,
     deltaX,
     lines,
-    minLineY,
-    numberOfVisibleLines,
     width
   } = editor;
-  const maxLineY = Math.min(minLineY + numberOfVisibleLines, lines.length);
+  const visibleLineIndices = editor.visibleLineIndices || Array.from({
+    length: Math.min(editor.numberOfVisibleLines, lines.length - editor.minLineY)
+  }, (_, index) => editor.minLineY + index);
+  if (visibleLineIndices.length === 0) {
+    return {
+      differences: [],
+      textInfos: []
+    };
+  }
+  const minLineY = visibleLineIndices[0];
+  const maxLineY = visibleLineIndices.at(-1) + 1;
   // @ts-ignore
   let {
     embeddedResults,
@@ -3113,58 +3354,13 @@ const getVisible$1 = async (editor, syncIncremental) => {
   const minLineOffset = await offsetAtSync(editor, minLineY, 0);
   const averageCharWidth = charWidth;
   const {
-    differences,
-    result
+    differences: allDifferences,
+    result: allTextInfos
   } = getLineInfosViewport(editor, tokens, embeddedResults, minLineY, maxLineY, minLineOffset, width, deltaX, averageCharWidth);
+  const relativeIndices = visibleLineIndices.map(rowIndex => rowIndex - minLineY);
   return {
-    differences,
-    textInfos: result
-  };
-};
-
-const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
-  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
-  if (!Number.isFinite(scrollBarOffset)) {
-    return 0;
-  }
-  return scrollBarOffset;
-};
-const getScrollBarY = getScrollBarOffset;
-
-const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
-  if (size >= contentSize) {
-    return 0;
-  }
-  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
-};
-
-const getScrollBarWidth = (width, longestLineWidth) => {
-  if (width > longestLineWidth) {
-    return 0;
-  }
-  return width ** 2 / longestLineWidth;
-};
-
-const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
-  const halfScrollBarHeight = scrollBarHeight / 2;
-  if (relativeY <= halfScrollBarHeight) {
-    // clicked at top
-    return {
-      handleOffset: relativeY,
-      percent: 0
-    };
-  }
-  if (relativeY <= height - halfScrollBarHeight) {
-    // clicked in middle
-    return {
-      handleOffset: halfScrollBarHeight,
-      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight)
-    };
-  }
-  // clicked at bottom
-  return {
-    handleOffset: scrollBarHeight - height + relativeY,
-    percent: 1
+    differences: relativeIndices.map(index => allDifferences[index]),
+    textInfos: relativeIndices.map(index => allTextInfos[index])
   };
 };
 
@@ -3194,15 +3390,22 @@ const setDeltaY$2 = async (state, value) => {
   if (deltaY === newDeltaY) {
     return state;
   }
-  const newMinLineY = Math.floor(newDeltaY / itemHeight);
-  const newMaxLineY = newMinLineY + numberOfVisibleLines;
-  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height, scrollBarHeight);
-  const newEditor1 = {
+  const minLineY = Math.floor(newDeltaY / itemHeight);
+  const maxLineY = minLineY + numberOfVisibleLines;
+  const newEditor1 = state.foldingRanges?.length > 0 ? updateLayout({
+    ...state,
+    deltaY: newDeltaY
+  }, state.foldingRanges) : {
     ...state,
     deltaY: newDeltaY,
-    maxLineY: newMaxLineY,
-    minLineY: newMinLineY,
-    scrollBarY
+    maxLineY,
+    minLineY,
+    scrollBarY: getScrollBarY(newDeltaY, finalDeltaY, height, scrollBarHeight),
+    ...('visibleLineIndices' in state && {
+      visibleLineIndices: Array.from({
+        length: Math.max(Math.min(maxLineY, state.lines.length) - minLineY, 0)
+      }, (_, index) => minLineY + index)
+    })
   };
   const syncIncremental = getEnabled();
   const {
@@ -3472,29 +3675,41 @@ const resize = (state, dimensions, columnWidth = state.columnWidth) => {
   const width = dimensions.width ?? state.width;
   const height = dimensions.height ?? state.height;
   const numberOfVisibleLines = Math.floor(height / state.itemHeight);
-  const total = state.lines.length;
-  const finalY = Math.max(total - numberOfVisibleLines, 0);
-  const finalDeltaY = finalY * state.itemHeight;
-  const deltaY = Math.min(state.deltaY, finalDeltaY);
-  const minLineY = Math.floor(deltaY / state.itemHeight);
-  const maxLineY = Math.min(minLineY + numberOfVisibleLines, total);
-  const contentHeight = total * state.rowHeight;
-  const scrollBarHeight = getScrollBarSize(height, contentHeight, state.minimumSliderSize);
-  return {
+  if (!('foldingRanges' in state)) {
+    const total = state.lines.length;
+    const finalY = Math.max(total - numberOfVisibleLines, 0);
+    const finalDeltaY = finalY * state.itemHeight;
+    const deltaY = Math.min(state.deltaY, finalDeltaY);
+    const minLineY = Math.floor(deltaY / state.itemHeight);
+    const maxLineY = Math.min(minLineY + numberOfVisibleLines, total);
+    const contentHeight = total * state.rowHeight;
+    const scrollBarHeight = getScrollBarSize(height, contentHeight, state.minimumSliderSize);
+    return {
+      ...state,
+      columnWidth,
+      deltaY,
+      finalDeltaY,
+      finalY,
+      height,
+      maxLineY,
+      minLineY,
+      numberOfVisibleLines,
+      scrollBarHeight,
+      width,
+      x,
+      y
+    };
+  }
+  const resized = {
     ...state,
     columnWidth,
-    deltaY,
-    finalDeltaY,
-    finalY,
     height,
-    maxLineY,
-    minLineY,
     numberOfVisibleLines,
-    scrollBarHeight,
     width,
     x,
     y
   };
+  return updateLayout(resized, state.foldingRanges);
 };
 
 const splitLines = lines => {
@@ -3587,10 +3802,6 @@ const getX = async (line, column, fontWeight, fontSize, fontFamily, isMonospaceF
   return textWidth - halfCursorWidth + difference;
 };
 
-const getY = (row, minLineY, rowHeight) => {
-  return (row - minLineY) * rowHeight;
-};
-
 const px = value => {
   return `${value}px`;
 };
@@ -3699,12 +3910,15 @@ const getVisible = async editor => {
   const {
     charWidth,
     cursorWidth,
+    deltaY,
     differences,
     focused,
+    foldingRanges = [],
     fontFamily,
     fontSize,
     fontWeight,
     isMonospaceFont,
+    itemHeight,
     letterSpacing,
     lines,
     maxLineY,
@@ -3712,26 +3926,35 @@ const getVisible = async editor => {
     rowHeight,
     selections,
     tabSize,
+    visibleLineIndices,
     width
   } = editor;
   const averageCharWidth = charWidth;
   const halfCursorWidth = cursorWidth / 2;
+  const actualVisibleLineIndices = visibleLineIndices || Array.from({
+    length: maxLineY - minLineY
+  }, (_, index) => minLineY + index);
+  const startVisualRow = itemHeight ? Math.floor(deltaY / itemHeight) : getVisualRowForDocumentRow(minLineY, foldingRanges);
+  const endVisualRow = startVisualRow + actualVisibleLineIndices.length;
+  const getRelativeRow = rowIndex => getVisualRowForDocumentRow(rowIndex, foldingRanges) - startVisualRow;
   for (let i = 0; i < selections.length; i += 4) {
     const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn, reversed] = getSelectionPairs(selections, i);
-    if (selectionEndRow < minLineY || selectionStartRow > maxLineY) {
+    const selectionStartVisualRow = getVisualRowForDocumentRow(selectionStartRow, foldingRanges);
+    const selectionEndVisualRow = getVisualRowForDocumentRow(selectionEndRow, foldingRanges);
+    if (selectionEndVisualRow < startVisualRow || selectionStartVisualRow >= endVisualRow) {
       continue;
     }
-    const relativeEndLineRow = selectionEndRow - minLineY;
+    const relativeEndLineRow = getRelativeRow(selectionEndRow);
     const endLineDifference = differences[relativeEndLineRow];
     const endLine = lines[selectionEndRow];
     const endLineEndX = await getX(endLine, selectionEndColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, endLineDifference);
-    const endLineY = getY(selectionEndRow, minLineY, rowHeight);
+    const endLineY = relativeEndLineRow * rowHeight;
     if (isEmpty(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) && endLineEndX > 0) {
       visibleCursors.push(endLineEndX, endLineY);
       continue;
     }
-    const startLineY = getY(selectionStartRow, minLineY, rowHeight);
-    const startLineYRelative = selectionStartRow - minLineY;
+    const startLineYRelative = getRelativeRow(selectionStartRow);
+    const startLineY = startLineYRelative * rowHeight;
     const startLineDifference = differences[startLineYRelative];
     if (selectionStartRow === selectionEndRow) {
       const startX = await getX(endLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
@@ -3743,28 +3966,27 @@ const getVisible = async editor => {
       const selectionWidth = endLineEndX - startX;
       visibleSelections.push(startX, startLineY, selectionWidth, rowHeight);
     } else {
-      if (selectionStartRow >= minLineY) {
+      if (selectionStartVisualRow >= startVisualRow) {
         const startLine = lines[selectionStartRow];
         const startLineStartX = await getX(startLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
         const startLineEndX = await getX(startLine, startLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
-        const startLineStartY = getY(selectionStartRow, minLineY, rowHeight);
+        const startLineStartY = startLineYRelative * rowHeight;
         const selectionWidth = startLineEndX - startLineStartX;
         if (reversed) {
           visibleCursors.push(startLineStartX, startLineStartY);
         }
         visibleSelections.push(startLineStartX, startLineStartY, selectionWidth, rowHeight);
       }
-      const iMin = Math.max(selectionStartRow + 1, minLineY);
-      const iMax = Math.min(selectionEndRow, maxLineY);
-      for (let i = iMin; i < iMax; i++) {
-        const currentLine = lines[i];
-        const currentLineY = getY(i, minLineY, rowHeight);
-        const relativeLine = i - minLineY;
+      const selectedVisibleRows = actualVisibleLineIndices.filter(rowIndex => rowIndex > selectionStartRow && rowIndex < selectionEndRow);
+      for (const rowIndex of selectedVisibleRows) {
+        const currentLine = lines[rowIndex];
+        const relativeLine = getRelativeRow(rowIndex);
+        const currentLineY = relativeLine * rowHeight;
         const difference = differences[relativeLine];
         const selectionWidth = await getX(currentLine, currentLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference);
         visibleSelections.push(0, currentLineY, selectionWidth, rowHeight);
       }
-      if (selectionEndRow <= maxLineY) {
+      if (selectionEndVisualRow < endVisualRow) {
         const selectionWidth = endLineEndX;
         visibleSelections.push(0, endLineY, selectionWidth, rowHeight);
         if (!reversed) {
@@ -3809,13 +4031,72 @@ const getSelectionFromChange = change => {
 };
 const setSelections$1 = (editor, selections) => {
   object(editor);
-  // Assert.uint32array(selections)
-  return {
+  const {
+    foldingRanges = []
+  } = editor;
+  if ('foldingRanges' in editor) {
+    const normalizedSelections = foldingRanges.length === 0 ? selections : map(selections, (result, index, startRow, startColumn, endRow, endColumn) => {
+      const previousRow = editor.selections[index + 2] ?? endRow;
+      result[index] = getUnhiddenRow(startRow, previousRow, editor.lines.length, foldingRanges);
+      result[index + 1] = startColumn;
+      result[index + 2] = getUnhiddenRow(endRow, previousRow, editor.lines.length, foldingRanges);
+      result[index + 3] = endColumn;
+    });
+    const rowIndex = normalizedSelections[editor.primarySelectionIndex || 0];
+    const visualRow = getVisualRowForDocumentRow(rowIndex, foldingRanges);
+    const startVisualRow = Math.floor(editor.deltaY / editor.itemHeight);
+    const endVisualRow = startVisualRow + editor.numberOfVisibleLines;
+    if (visualRow >= startVisualRow && visualRow < endVisualRow) {
+      return {
+        ...editor,
+        selections: normalizedSelections
+      };
+    }
+    const desiredStartVisualRow = visualRow < startVisualRow ? visualRow : visualRow - editor.numberOfVisibleLines + 1;
+    return updateLayout({
+      ...editor,
+      deltaY: desiredStartVisualRow * editor.itemHeight,
+      selections: normalizedSelections
+    }, foldingRanges);
+  }
+  const newEditor = {
     ...editor,
     selections
   };
-  // editor.selections = selections
-  // GlobalEventBus.emitEvent('editor.selectionChange', editor, selections)
+  const {
+    maxLineY,
+    minLineY,
+    numberOfVisibleLines
+  } = editor;
+  if (maxLineY === undefined || minLineY === undefined || numberOfVisibleLines <= 0) {
+    return newEditor;
+  }
+  const rowIndex = selections[editor.primarySelectionIndex || 0];
+  if (rowIndex === undefined) {
+    return newEditor;
+  }
+  if (rowIndex >= minLineY && rowIndex < maxLineY) {
+    return newEditor;
+  }
+  const {
+    finalDeltaY,
+    height,
+    itemHeight,
+    lines,
+    scrollBarHeight
+  } = editor;
+  const desiredMinLineY = rowIndex < minLineY ? rowIndex : rowIndex - numberOfVisibleLines + 1;
+  const deltaY = clamp(desiredMinLineY * itemHeight, 0, finalDeltaY);
+  const newMinLineY = Math.floor(deltaY / itemHeight);
+  const newMaxLineY = Math.min(newMinLineY + numberOfVisibleLines, lines.length);
+  const scrollBarY = getScrollBarY(deltaY, finalDeltaY, height, scrollBarHeight);
+  return {
+    ...newEditor,
+    deltaY,
+    maxLineY: newMaxLineY,
+    minLineY: newMinLineY,
+    scrollBarY
+  };
 };
 
 // TODO maybe only accept sorted selection edits in the first place
@@ -3868,6 +4149,13 @@ const applyAutoClosingRangesEdit = (editor, changes) => {
 const scheduleSelections = (editor, selectionEdits) => {
   return setSelections$1(editor, selectionEdits);
 };
+const updateLines = (editor, lines) => {
+  const newEditor = {
+    ...editor,
+    lines
+  };
+  return 'foldingRanges' in editor ? updateLayout(newEditor, []) : newEditor;
+};
 
 /**
  * TODO make this synchronous maybe?
@@ -3883,10 +4171,7 @@ const scheduleDocumentAndCursorsSelections = async (editor, changes, selectionCh
     return editor;
   }
   const newLines = applyEdits(editor, changes);
-  const partialNewEditor = {
-    ...editor,
-    lines: newLines
-  };
+  const partialNewEditor = updateLines(editor, newLines);
   const newSelections = selectionChanges || applyEdit$1(partialNewEditor, changes);
   // TODO should separate rendering from business logic somehow
   // currently hard to test because need to mock editor height, top, left,
@@ -3956,10 +4241,7 @@ const scheduleDocumentAndCursorsSelectionIsUndo = async (editor, changes) => {
     return editor;
   }
   const newLines = applyEdits(editor, changes);
-  const partialNewEditor = {
-    ...editor,
-    lines: newLines
-  };
+  const partialNewEditor = updateLines(editor, newLines);
   const newSelections = applyEdit$1(partialNewEditor, changes);
   const invalidStartIndex = Math.min(editor.invalidStartIndex, changes[0].start.rowIndex);
   const newEditor = {
@@ -4008,9 +4290,8 @@ const scheduleDocument = async (editor, changes) => {
   // const scrollBarHeight = editor.scrollBarHeight
 
   const newEditor = {
-    ...editor,
+    ...updateLines(editor, newLines),
     invalidStartIndex,
-    lines: newLines,
     redoStack: [],
     undoStack: [...editor.undoStack, changes]
   };
@@ -4059,28 +4340,14 @@ const setBounds = (editor, x, y, width, height, columnWidth) => {
 };
 const setText$1 = (editor, text) => {
   const lines = splitLines(text);
-  const {
-    itemHeight,
-    minimumSliderSize,
-    numberOfVisibleLines
-  } = editor;
-  const total = lines.length;
-  const maxLineY = Math.min(numberOfVisibleLines, total);
-  const finalY = Math.max(total - numberOfVisibleLines, 0);
-  const finalDeltaY = finalY * itemHeight;
-  const contentHeight = lines.length * editor.rowHeight;
-  const scrollBarHeight = getScrollBarSize(editor.height, contentHeight, minimumSliderSize);
-  return {
+  return updateLayout({
     ...editor,
-    finalDeltaY,
-    finalY,
-    lines,
-    maxLineY,
-    scrollBarHeight
-  };
+    lines
+  }, []);
 };
 
 const emptyEditor = {
+  breakPoints: [],
   cursorInfos: [],
   debugEnabled: false,
   decorations: [],
@@ -4090,6 +4357,7 @@ const emptyEditor = {
   differences: [],
   embeds: [],
   focused: false,
+  foldingRanges: [],
   hasListener: false,
   height: 0,
   highlightedLine: -1,
@@ -4118,6 +4386,7 @@ const emptyEditor = {
   tokenizerId: 0,
   undoStack: [],
   uri: '',
+  visibleLineIndices: [],
   width: 0,
   x: 0,
   y: 0
@@ -4280,6 +4549,10 @@ const getDiagnosticType = diagnostic => {
   return diagnostic.type;
 };
 
+const getY = (row, minLineY, rowHeight) => {
+  return (row - minLineY) * rowHeight;
+};
+
 const getVisibleDiagnostics = async (editor, diagnostics) => {
   const visibleDiagnostics = [];
   const {
@@ -4443,6 +4716,7 @@ const createEditor = async ({
   const computedlanguageId = getLanguageId$1(uri, languages);
   const editor = {
     assetDir,
+    breakPoints: [],
     charWidth,
     columnWidth: 0,
     completionState: '',
@@ -4460,6 +4734,7 @@ const createEditor = async ({
     finalY: 0,
     focused: false,
     focusKey: Empty,
+    foldingRanges: [],
     fontFamily,
     fontSize,
     fontWeight,
@@ -4514,6 +4789,7 @@ const createEditor = async ({
     uri,
     useFunctionalRendering,
     validLines: [],
+    visibleLineIndices: [],
     widgets: [],
     width,
     x,
@@ -4565,6 +4841,10 @@ const createEditor = async ({
   });
 };
 
+const isEqual$4 = (oldState, newState) => {
+  return oldState.additionalFocus === newState.additionalFocus;
+};
+
 const isEqual$3 = (oldState, newState) => {
   return oldState.rowHeight === newState.rowHeight && oldState.deltaY === newState.deltaY && oldState.finalDeltaY === newState.finalDeltaY && oldState.height === newState.height && oldState.deltaX === newState.deltaX && oldState.longestLineWidth === newState.longestLineWidth && oldState.minimumSliderSize === newState.minimumSliderSize && oldState.width === newState.width && oldState.scrollBarHeight === newState.scrollBarHeight;
 };
@@ -4583,7 +4863,7 @@ const isEqual$2 = (oldState, newState) => {
 };
 
 const isEqual$1 = (oldState, newState) => {
-  return oldState.cursorInfos === newState.cursorInfos && oldState.diagnostics === newState.diagnostics && oldState.highlightedLine === newState.highlightedLine && oldState.lineNumbers === newState.lineNumbers && oldState.loadError === newState.loadError && oldState.textInfos === newState.textInfos && oldState.differences === newState.differences && oldState.initial === newState.initial && oldState.selectionInfos === newState.selectionInfos;
+  return oldState.breakPoints === newState.breakPoints && oldState.cursorInfos === newState.cursorInfos && oldState.diagnostics === newState.diagnostics && oldState.highlightedLine === newState.highlightedLine && oldState.lineNumbers === newState.lineNumbers && oldState.loadError === newState.loadError && oldState.textInfos === newState.textInfos && oldState.differences === newState.differences && oldState.initial === newState.initial && oldState.selectionInfos === newState.selectionInfos;
 };
 
 const RenderFocus = 6;
@@ -4591,13 +4871,14 @@ const RenderFocusContext = 7;
 const RenderCss = 11;
 const RenderIncremental = 12;
 const RenderWidgets = 13;
+const RenderAdditionalFocusContext = 14;
 
 const isEqual = (oldState, newState) => {
   return oldState.widgets === newState.widgets;
 };
 
-const modules = [isEqual$1, isEqual$2, isEqual$2, isEqual$3, isEqual];
-const numbers = [RenderIncremental, RenderFocus, RenderFocusContext, RenderCss, RenderWidgets];
+const modules = [isEqual$1, isEqual$2, isEqual$2, isEqual$4, isEqual$3, isEqual];
+const numbers = [RenderIncremental, RenderFocus, RenderFocusContext, RenderAdditionalFocusContext, RenderCss, RenderWidgets];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -4857,6 +5138,25 @@ const applyWorkspaceEdit = async (editor, changes) => {
   return scheduleDocumentAndCursorsSelections(editor, textChanges);
 };
 
+const isPersistentWidget = widgetId => {
+  switch (widgetId) {
+    case Find:
+      return true;
+    default:
+      return false;
+  }
+};
+
+// TODO widgets should have a persistence property:
+// 1 = close by click (e.g. completion, hover, source-actions)
+// 2 = stay open on click (e.g. find)
+const closeWidgetsMaybe = widgets => {
+  if (widgets.length === 0) {
+    return widgets;
+  }
+  return widgets.filter(widget => isPersistentWidget(widget.id));
+};
+
 const getFormattingEdits = async editor => {
   const textDocument = {
     documentId: editor.id || editor.uid,
@@ -4988,6 +5288,7 @@ const at = async (editor, eventX, eventY) => {
     charWidth,
     deltaX,
     deltaY,
+    foldingRanges = [],
     fontFamily,
     fontSize,
     fontWeight,
@@ -4999,13 +5300,14 @@ const at = async (editor, eventX, eventY) => {
     x,
     y
   } = editor;
-  const rowIndex = Math.floor((eventY - y + deltaY) / rowHeight);
-  if (rowIndex < 0) {
+  const visualRowIndex = Math.floor((eventY - y + deltaY) / rowHeight);
+  if (visualRowIndex < 0) {
     return {
       columnIndex: 0,
       rowIndex: 0
     };
   }
+  const rowIndex = getDocumentRowForVisualRow(visualRowIndex, foldingRanges);
   const relativeX = eventX - x + deltaX;
   const clampedRowIndex = clamp(rowIndex, 0, lines.length - 1);
   const line = lines[clampedRowIndex];
@@ -5225,7 +5527,9 @@ const handleBlur$1 = async editor => {
   }
   const newEditor = {
     ...editor,
-    focused: false
+    additionalFocus: 0,
+    focused: false,
+    widgets: closeWidgetsMaybe(editor.widgets || [])
   };
   if (!editor.modified) {
     return newEditor;
@@ -5374,6 +5678,21 @@ const closeCodeGenerator = editor => {
   };
 };
 
+const closeCompletion = editor => {
+  const {
+    widgets
+  } = editor;
+  if (widgets.every(widget => widget.id !== Completion)) {
+    return editor;
+  }
+  return {
+    ...editor,
+    additionalFocus: 0,
+    focused: true,
+    widgets: removeEditorWidget(widgets, Completion)
+  };
+};
+
 const isMatchingWidget$1 = widget => {
   return widget.id === Find;
 };
@@ -5388,6 +5707,8 @@ const closeFind = editor => {
   const newWidgets = removeEditorWidget(widgets, Find);
   return {
     ...editor,
+    additionalFocus: 0,
+    focus: FocusEditorText$1,
     focused: true,
     widgets: newWidgets
   };
@@ -5706,6 +6027,10 @@ const copyLineUp = editor => {
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
+const getLineLength = line => {
+  return line.endsWith('\r') ? line.length - 1 : line.length;
+};
+
 // @ts-ignore
 const editorGetPositionLeft = (rowIndex, columnIndex, lines, getDelta) => {
   if (columnIndex === 0) {
@@ -5716,7 +6041,7 @@ const editorGetPositionLeft = (rowIndex, columnIndex, lines, getDelta) => {
       };
     }
     return {
-      columnIndex: lines[rowIndex - 1].length,
+      columnIndex: getLineLength(lines[rowIndex - 1]),
       rowIndex: rowIndex - 1
     };
   }
@@ -5747,7 +6072,7 @@ const moveToPositionLeft = (selections, i, rowIndex, columnIndex, lines, getDelt
       selections[i + 1] = 0;
     } else {
       selections[i] = rowIndex - 1;
-      selections[i + 1] = lines[rowIndex - 1].length;
+      selections[i + 1] = getLineLength(lines[rowIndex - 1]);
     }
   } else {
     const delta = getDelta(lines[rowIndex], columnIndex);
@@ -5834,7 +6159,7 @@ const lineCharacterStart = (line, columnIndex) => {
   return columnIndex;
 };
 const lineEnd = (line, columnIndex) => {
-  return line.length - columnIndex;
+  return getLineLength(line) - columnIndex;
 };
 const tryRegexArray = (partialLine, regexArray) => {
   for (const regex of regexArray) {
@@ -5912,7 +6237,7 @@ const editorGetPositionRight = (position, lines, getDelta) => {
   const {
     columnIndex
   } = position;
-  if (columnIndex >= lines[rowIndex].length) {
+  if (columnIndex >= getLineLength(lines[rowIndex])) {
     if (rowIndex >= lines.length) {
       return position;
     }
@@ -5932,7 +6257,7 @@ const moveToPositionRight = (selections, i, rowIndex, columnIndex, lines, getDel
     return;
   }
   const line = lines[rowIndex];
-  if (columnIndex >= line.length) {
+  if (columnIndex >= getLineLength(line)) {
     selections[i] = selections[i + 2] = rowIndex + 1;
     selections[i + 1] = selections[i + 3] = 0;
   } else {
@@ -5969,6 +6294,28 @@ const cursorCharacterRight = editor => {
   return editorCursorHorizontalRight(editor, characterRight);
 };
 
+const cursorDocumentEnd = editor => {
+  const {
+    lines,
+    selections
+  } = editor;
+  const rowIndex = lines.length - 1;
+  const columnIndex = lines[rowIndex].length;
+  const newSelections = new Uint32Array(selections.length);
+  for (let i = 0; i < newSelections.length; i += 4) {
+    newSelections[i] = rowIndex;
+    newSelections[i + 1] = columnIndex;
+    newSelections[i + 2] = rowIndex;
+    newSelections[i + 3] = columnIndex;
+  }
+  return scheduleSelections(editor, newSelections);
+};
+
+const cursorDocumentStart = editor => {
+  const newSelections = new Uint32Array(editor.selections.length);
+  return scheduleSelections(editor, newSelections);
+};
+
 const moveSelectionDown = (selections, i, selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
   moveRangeToPosition$1(selections, i, selectionEndRow + 1, selectionEndColumn);
 };
@@ -5993,6 +6340,23 @@ const cursorHome = editor => {
   return editorCursorHorizontalLeft(editor, lineCharacterStart);
 };
 
+const cursorPageDown = editor => {
+  const {
+    deltaY,
+    itemHeight,
+    lines,
+    numberOfVisibleLines,
+    selections
+  } = editor;
+  const pageSize = Math.max(numberOfVisibleLines, 1);
+  const lastRowIndex = lines.length - 1;
+  const newSelections = map(selections, (result, index, _startRow, _startColumn, endRow, endColumn) => {
+    moveRangeToPosition$1(result, index, Math.min(endRow + pageSize, lastRowIndex), endColumn);
+  });
+  const newEditor = scheduleSelections(editor, newSelections);
+  return setDeltaYFixedValue$1(newEditor, deltaY + pageSize * itemHeight);
+};
+
 const cursorSet = (editor, rowIndex, columnIndex) => {
   object(editor);
   number(rowIndex);
@@ -6272,6 +6636,93 @@ const deleteCharacterRight = editor => {
   return editorDeleteHorizontalRight(editor, characterRight);
 };
 
+const getDeleteLineOperations = selections => {
+  const operations = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const [startRowIndex,, selectionEndRowIndex, endColumnIndex] = getSelectionPairs(selections, i);
+    const endRowIndex = startRowIndex < selectionEndRowIndex && endColumnIndex === 0 ? selectionEndRowIndex - 1 : selectionEndRowIndex;
+    operations.push({
+      endRowIndex,
+      positionColumnIndex: selections[i + 3],
+      startRowIndex
+    });
+  }
+  operations.sort((a, b) => a.startRowIndex - b.startRowIndex || a.endRowIndex - b.endRowIndex);
+  const mergedOperations = [];
+  for (const operation of operations) {
+    const previous = mergedOperations.at(-1);
+    if (previous && previous.endRowIndex + 1 >= operation.startRowIndex) {
+      mergedOperations[mergedOperations.length - 1] = {
+        ...previous,
+        endRowIndex: Math.max(previous.endRowIndex, operation.endRowIndex)
+      };
+    } else {
+      mergedOperations.push(operation);
+    }
+  }
+  return mergedOperations;
+};
+const deleteLine$1 = async editor => {
+  const {
+    lines,
+    selections
+  } = editor;
+  if (lines.length === 1 && lines[0] === '') {
+    return editor;
+  }
+  const operations = getDeleteLineOperations(selections);
+  const changes = [];
+  const selectionChanges = new Uint32Array(operations.length * 4);
+  const lastRowIndex = lines.length - 1;
+  let linesDeleted = 0;
+  for (let i = 0; i < operations.length; i++) {
+    const operation = operations[i];
+    let {
+      endRowIndex,
+      startRowIndex
+    } = operation;
+    let startColumnIndex = 0;
+    let endColumnIndex = lines[endRowIndex].length;
+    let survivingLine = '';
+    if (endRowIndex < lastRowIndex) {
+      endRowIndex++;
+      endColumnIndex = 0;
+      survivingLine = lines[endRowIndex];
+    } else if (startRowIndex > 0) {
+      startRowIndex--;
+      startColumnIndex = lines[startRowIndex].length;
+      survivingLine = lines[startRowIndex];
+    }
+    const start = {
+      columnIndex: startColumnIndex,
+      rowIndex: startRowIndex
+    };
+    const end = {
+      columnIndex: endColumnIndex,
+      rowIndex: endRowIndex
+    };
+    changes.push({
+      deleted: getSelectionText(editor, {
+        end,
+        start
+      }),
+      end,
+      inserted: [''],
+      origin: Delete,
+      start
+    });
+    const cursorRowIndex = startRowIndex - linesDeleted;
+    const cursorColumnIndex = Math.min(operation.positionColumnIndex, survivingLine.length);
+    const offset = i * 4;
+    selectionChanges[offset] = cursorRowIndex;
+    selectionChanges[offset + 1] = cursorColumnIndex;
+    selectionChanges[offset + 2] = cursorRowIndex;
+    selectionChanges[offset + 3] = cursorColumnIndex;
+    linesDeleted += operation.endRowIndex - operation.startRowIndex + 1;
+  }
+  return scheduleDocumentAndCursorsSelections(editor, changes, selectionChanges);
+};
+
 const deleteWordLeft = editor => {
   const newEditor = editorDeleteHorizontalLeft(editor, wordLeft);
   return newEditor;
@@ -6296,6 +6747,38 @@ const findAllReferences$1 = async editor => {
   return editor;
 };
 
+const fold$1 = editor => {
+  const {
+    foldingRanges = [],
+    lines,
+    primarySelectionIndex = 0,
+    selections
+  } = editor;
+  const rowIndex = selections[primarySelectionIndex];
+  const range = findRange(lines, rowIndex);
+  if (!range) {
+    return editor;
+  }
+  const newRanges = addRange(foldingRanges, range);
+  if (newRanges === foldingRanges) {
+    return editor;
+  }
+  const newSelections = map(selections, (result, index, startRow, startColumn, endRow, endColumn) => {
+    if (startRow >= range.start && endRow <= range.end) {
+      moveRangeToPosition$1(result, index, range.start, Math.min(endColumn, lines[range.start].length));
+      return;
+    }
+    result[index] = startRow;
+    result[index + 1] = startColumn;
+    result[index + 2] = endRow;
+    result[index + 3] = endColumn;
+  });
+  return updateLayout({
+    ...editor,
+    selections: newSelections
+  }, newRanges);
+};
+
 /* eslint-disable sonarjs/super-linear-regex */
 
 const RE_WORD_START$1 = /^[\w\-]+/;
@@ -6361,6 +6844,7 @@ const i18nString = (key, placeholders = emptyObject) => {
 
 const Copy = 'Copy';
 const Cut = 'Cut';
+const DeleteLine = 'Delete Line';
 const EditorCloseColorPicker = 'Editor: Close Color Picker';
 const EditorCopyLineDown = 'Editor: Copy Line Down';
 const EditorCopyLineUp = 'Editor: Copy Line Up';
@@ -6382,6 +6866,7 @@ const EnterCode = 'Enter Code';
 const EscapeToClose = 'Escape to close';
 const FindAllImplementations = 'Find All Implementations';
 const FindAllReferences = 'Find All References';
+const Fold = 'Editor: Fold';
 const FormatDocument = 'Format Document';
 const GoToDefinition = 'Go to Definition';
 const GoToTypeDefinition = 'Go to Type Definition';
@@ -6394,6 +6879,8 @@ const NoTypeDefinitionFoundFor = "No type definition found for '{PH1}'";
 const Paste = 'Paste';
 const SourceAction = 'Source Action';
 const ToggleBlockComment = 'Toggle Block Comment';
+const ToggleBreakpoint = 'Toggle Breakpoint';
+const Unfold = 'Editor: Unfold';
 
 const goToDefinition$1 = () => {
   return i18nString(GoToDefinition);
@@ -6429,21 +6916,33 @@ const goToTypeDefinition$1 = () => {
 const findAllReferences = () => {
   return i18nString(FindAllReferences);
 };
+const fold = () => {
+  return i18nString(Fold);
+};
 const findAllImplementations = () => {
   return i18nString(FindAllImplementations);
 };
 const cut = () => {
   return i18nString(Cut);
 };
+const deleteLine = () => {
+  return i18nString(DeleteLine);
+};
 const copy = () => {
   return i18nString(Copy);
 };
 const paste$1 = () => {
   return i18nString(Paste);
 };
+const unfold$1 = () => {
+  return i18nString(Unfold);
+};
 const toggleBlockComment$1 = () => {
   return i18nString(ToggleBlockComment);
 };
+const toggleBreakpoint$1 = () => {
+  return i18nString(ToggleBreakpoint);
+};
 const moveLineUp$1 = () => {
   return i18nString(MoveLineUp);
 };
@@ -6640,25 +7139,6 @@ const goToTypeDefinition = async (editor, explicit = true) => {
   });
 };
 
-const isPersistentWidget = widgetId => {
-  switch (widgetId) {
-    case Find:
-      return true;
-    default:
-      return false;
-  }
-};
-
-// TODO widgets should have a persistence property:
-// 1 = close by click (e.g. completion, hover, source-actions)
-// 2 = stay open on click (e.g. find)
-const closeWidgetsMaybe = widgets => {
-  if (widgets.length === 0) {
-    return widgets;
-  }
-  return widgets.filter(isPersistentWidget);
-};
-
 const openExternal = async (url, platform) => {
   await openUrl(url, platform);
 };
@@ -6915,7 +7395,30 @@ const handleTripleClick = (editor, modifier, x, y) => {
 };
 
 const PrimaryButton = 0;
+const SecondaryButton = 2;
+const isPositionBeforeOrEqual = (rowIndex, columnIndex, otherRowIndex, otherColumnIndex) => {
+  return rowIndex < otherRowIndex || rowIndex === otherRowIndex && columnIndex <= otherColumnIndex;
+};
+const isPositionInSelection = (selections, rowIndex, columnIndex) => {
+  for (let i = 0; i < selections.length; i += 4) {
+    const [startRowIndex, startColumnIndex, endRowIndex, endColumnIndex] = getSelectionPairs(selections, i);
+    if (isPositionBeforeOrEqual(startRowIndex, startColumnIndex, rowIndex, columnIndex) && isPositionBeforeOrEqual(rowIndex, columnIndex, endRowIndex, endColumnIndex)) {
+      return true;
+    }
+  }
+  return false;
+};
+const handleSecondaryMouseDown = async (state, x, y) => {
+  const position = await at(state, x, y);
+  if (isPositionInSelection(state.selections, position.rowIndex, position.columnIndex)) {
+    return state;
+  }
+  return handleClickAtPosition(state, 0, position.rowIndex, position.columnIndex);
+};
 const handleMouseDown = async (state, button, altKey, ctrlKey, x, y, detail) => {
+  if (button === SecondaryButton) {
+    return handleSecondaryMouseDown(state, x, y);
+  }
   if (button !== PrimaryButton) {
     return state;
   }
@@ -7162,29 +7665,30 @@ const requestAnimationFrame = fn => {
 };
 
 const shouldUpdateSelectionData = (oldState, newState) => {
-  return oldState.selections !== newState.selections || oldState.focused !== newState.focused || oldState.minLineY !== newState.minLineY || oldState.maxLineY !== newState.maxLineY || oldState.differences !== newState.differences || oldState.charWidth !== newState.charWidth || oldState.cursorWidth !== newState.cursorWidth || oldState.fontFamily !== newState.fontFamily || oldState.fontSize !== newState.fontSize || oldState.fontWeight !== newState.fontWeight || oldState.isMonospaceFont !== newState.isMonospaceFont || oldState.letterSpacing !== newState.letterSpacing || oldState.lines !== newState.lines || oldState.rowHeight !== newState.rowHeight || oldState.tabSize !== newState.tabSize || oldState.width !== newState.width;
+  return oldState.selections !== newState.selections || oldState.focused !== newState.focused || oldState.minLineY !== newState.minLineY || oldState.maxLineY !== newState.maxLineY || oldState.foldingRanges !== newState.foldingRanges || oldState.differences !== newState.differences || oldState.charWidth !== newState.charWidth || oldState.cursorWidth !== newState.cursorWidth || oldState.fontFamily !== newState.fontFamily || oldState.fontSize !== newState.fontSize || oldState.fontWeight !== newState.fontWeight || oldState.isMonospaceFont !== newState.isMonospaceFont || oldState.letterSpacing !== newState.letterSpacing || oldState.lines !== newState.lines || oldState.rowHeight !== newState.rowHeight || oldState.tabSize !== newState.tabSize || oldState.width !== newState.width;
 };
 const shouldUpdateVisibleTextData = (oldState, newState) => {
   if (oldState.textInfos !== newState.textInfos || oldState.differences !== newState.differences) {
     return false;
   }
-  return oldState.lines !== newState.lines || oldState.tokenizerId !== newState.tokenizerId || oldState.minLineY !== newState.minLineY || oldState.maxLineY !== newState.maxLineY || oldState.decorations !== newState.decorations || oldState.embeds !== newState.embeds || oldState.deltaX !== newState.deltaX || oldState.width !== newState.width || oldState.highlightedLine !== newState.highlightedLine || oldState.debugEnabled !== newState.debugEnabled;
+  return oldState.lines !== newState.lines || oldState.tokenizerId !== newState.tokenizerId || oldState.minLineY !== newState.minLineY || oldState.maxLineY !== newState.maxLineY || oldState.decorations !== newState.decorations || oldState.embeds !== newState.embeds || oldState.deltaX !== newState.deltaX || oldState.width !== newState.width || oldState.highlightedLine !== newState.highlightedLine || oldState.foldingRanges !== newState.foldingRanges || oldState.debugEnabled !== newState.debugEnabled;
 };
 const updateDerivedState = async (oldState, newState) => {
-  let finalState = newState;
-  if (shouldUpdateVisibleTextData(oldState, newState)) {
+  const nextState = oldState.lines !== newState.lines && 'foldingRanges' in newState ? updateLayout(newState, []) : newState;
+  let finalState = nextState;
+  if (shouldUpdateVisibleTextData(oldState, nextState)) {
     const syncIncremental = getEnabled();
     const {
       differences,
       textInfos
-    } = await getVisible$1(newState, syncIncremental);
+    } = await getVisible$1(nextState, syncIncremental);
     finalState = {
-      ...newState,
+      ...nextState,
       differences,
       textInfos
     };
   }
-  if (!shouldUpdateSelectionData(oldState, newState)) {
+  if (!shouldUpdateSelectionData(oldState, nextState)) {
     return finalState;
   }
   const {
@@ -7879,30 +8383,50 @@ const openCompletion = async editor => {
   return addWidgetToEditor(Completion, EditorCompletion, editor, create$4, newStateGenerator$4, fullFocus);
 };
 
-const create$3 = () => {
-  const uid = create$8();
-  const widget = {
-    id: Find,
-    newState: {
-      commands: [],
-      editorUid: 0,
-      height: 0,
-      uid,
-      width: 0,
-      x: 0,
-      y: 0
-    },
-    oldState: {
-      commands: [],
-      editorUid: 0,
-      height: 0,
-      uid,
-      width: 0,
-      x: 0,
-      y: 0
-    }
-  };
-  return widget;
+const isFunctional = widgetId => {
+  switch (widgetId) {
+    case Message:
+    case ColorPicker$1:
+    case Completion:
+    case Find:
+    case Hover:
+    case Rename$1:
+    case SourceAction$1:
+      return true;
+    default:
+      return false;
+  }
+};
+const addWidget = (widget, id, render) => {
+  const commands = render(widget);
+  // TODO how to generate a unique integer id
+  // that doesn't collide with ids created in renderer worker?
+  // @ts-ignore
+  const {
+    uid
+  } = widget.newState;
+  const allCommands = [];
+  allCommands.push(['Viewlet.createFunctionalRoot', id, uid, isFunctional(widget.id)]);
+  allCommands.push(...commands);
+  if (isFunctional(widget.id)) {
+    allCommands.push(['Viewlet.appendToBody', uid]);
+  } else {
+    allCommands.push(['Viewlet.send', uid, 'appendWidget']);
+  }
+  const focusCommandIndex = allCommands.findIndex(command => {
+    return command[2] === 'focus' || command[0] === 'Viewlet.focusSelector';
+  });
+  // TODO have separate rendering functions, e.g.
+  // 1. renderDom
+  // 2. renderAriaAnnouncement
+  // 3. renderFocus
+  // to ensure that focus is always after the element is added to the DOM
+  if (focusCommandIndex !== -1) {
+    const command = allCommands[focusCommandIndex];
+    allCommands.splice(focusCommandIndex, 1);
+    allCommands.push(command);
+  }
+  return allCommands;
 };
 
 const launchFindWidgetWorker = async () => {
@@ -7936,28 +8460,336 @@ const dispose = async () => {
   // await rpc.dispose()
 };
 
-const getEditor$1 = editorUid => {
-  const instance = get$7(editorUid);
-  if (!instance) {
-    throw new Error(`editor ${editorUid} not found`);
+const launchHoverWorker = async () => {
+  const name = 'Hover Worker';
+  const url = 'hoverWorkerMain.js';
+  const intializeCommand = 'Hover.initialize';
+  const rpc = await launchWorker(name, url, intializeCommand);
+  return rpc;
+};
+
+const state$2 = {};
+const getOrCreate$1 = () => {
+  if (!state$2.workerPromise) {
+    state$2.workerPromise = launchHoverWorker();
   }
-  const {
-    newState
-  } = instance;
-  return newState;
+  return state$2.workerPromise;
+};
+const invoke$2 = async (method, ...params) => {
+  const worker = await getOrCreate$1();
+  return await worker.invoke(method, ...params);
 };
 
-const loadContent$2 = async (state, parentUid) => {
-  const {
-    uid
-  } = state;
-  const editor = getEditor$1(parentUid);
-  const {
-    height,
-    width,
-    x,
-    y
-  } = editor;
+const launchSourceActionWorker = async () => {
+  const name = 'Source Action Worker';
+  const url = 'sourceActionWorkerMain.js';
+  const intializeCommand = 'SourceActions.initialize';
+  const rpc = await launchWorker(name, url, intializeCommand);
+  return rpc;
+};
+
+const state$1 = {};
+const getOrCreate = () => {
+  if (!state$1.workerPromise) {
+    state$1.workerPromise = launchSourceActionWorker();
+  }
+  return state$1.workerPromise;
+};
+const invoke$1 = async (method, ...params) => {
+  const worker = await getOrCreate();
+  return await worker.invoke(method, ...params);
+};
+
+const getWidgetInvoke = widgetId => {
+  switch (widgetId) {
+    case ColorPicker$1:
+      return invoke$9;
+    case Completion:
+      return invoke$4;
+    case Find:
+      return invoke$3;
+    case Hover:
+      return invoke$2;
+    case Rename$1:
+      return invoke$5;
+    case SourceAction$1:
+      return invoke$1;
+    default:
+      return undefined;
+  }
+};
+
+const SearchValue = 'search-value';
+const Close = 'Close';
+
+const updateWidget = (editor, widgetId, newState) => {
+  // TODO avoid closure
+  const isWidget = widget => {
+    return widget.id === widgetId;
+  };
+  const childIndex = editor.widgets.findIndex(isWidget);
+  if (childIndex === -1) {
+    return editor;
+  }
+  // TODO scroll up/down if necessary
+  const childWidget = editor.widgets[childIndex];
+  const newWidget = {
+    ...childWidget,
+    newState,
+    oldState: childWidget.newState
+  };
+  const newWidgets = [...editor.widgets.slice(0, childIndex), newWidget, ...editor.widgets.slice(childIndex + 1)];
+  return {
+    ...editor,
+    widgets: newWidgets
+  };
+};
+
+const getEditorByWidgetUid = (widgetUid, widgetId) => {
+  for (const key of getKeys$2()) {
+    const editor = get$7(Number(key)).newState;
+    const widgets = editor.widgets || [];
+    for (const widget of widgets) {
+      if (widget.id === widgetId && widget.newState.uid === widgetUid) {
+        return editor;
+      }
+    }
+  }
+  return undefined;
+};
+const getEditor$1 = (editorOrUid, widgetId) => {
+  if (editorOrUid && editorOrUid.widgets) {
+    return editorOrUid;
+  }
+  const instance = get$7(editorOrUid);
+  if (instance && instance.newState && instance.newState.widgets) {
+    return instance.newState;
+  }
+  return getEditorByWidgetUid(editorOrUid, widgetId);
+};
+const createFn = (key, name, widgetId) => {
+  const isWidget = widget => {
+    return widget.id === widgetId;
+  };
+  const isClose = args => {
+    return key === 'close' || key === 'handleClickButton' && args.includes(Close);
+  };
+  const fn = async (editorOrUid, ...args) => {
+    const editor = getEditor$1(editorOrUid, widgetId);
+    if (!editor) {
+      return editorOrUid;
+    }
+    const childIndex = editor.widgets.findIndex(isWidget);
+    if (childIndex === -1) {
+      return editor;
+    }
+    // TODO scroll up/down if necessary
+    const childWidget = editor.widgets[childIndex];
+    const state = childWidget.newState;
+    const {
+      uid
+    } = state;
+    const invoke = getWidgetInvoke(widgetId);
+    await invoke(`${name}.${key}`, uid, ...args);
+    const diff = await invoke(`${name}.diff2`, uid);
+    const commands = await invoke(`${name}.render2`, uid, diff);
+    const latest = get$7(editor.uid).newState;
+    if (isClose(args)) {
+      const newEditor = {
+        ...latest,
+        focused: true,
+        widgets: removeEditorWidget(latest.widgets, widgetId)
+      };
+      set$9(editor.uid, latest, newEditor);
+      return newEditor;
+    }
+    const newState = {
+      ...state,
+      commands
+    };
+    const newEditor = updateWidget(latest, widgetId, newState);
+    set$9(editor.uid, latest, newEditor);
+    return newEditor;
+  };
+  return fn;
+};
+const createFns = (keys, name, widgetId) => {
+  const fns = Object.create(null);
+  for (const key of keys) {
+    fns[key] = createFn(key, name, widgetId);
+  }
+  return fns;
+};
+
+const renderFull$4 = (oldState, newState) => {
+  const commands = [...newState.commands];
+  // @ts-ignore
+  newState.commands = [];
+  return commands;
+};
+
+const AppendToBody = 'Viewlet.appendToBody';
+const Focus = 'focus';
+const FocusSelector = 'Viewlet.focusSelector';
+const RegisterEventListeners = 'Viewlet.registerEventListeners';
+const SetSelectionByName = 'Viewlet.setSelectionByName';
+const SetValueByName = 'Viewlet.setValueByName';
+const SetFocusContext = 'Viewlet.setFocusContext';
+const SetBounds = 'setBounds';
+const SetBounds2 = 'Viewlet.setBounds';
+const SetCss = 'Viewlet.setCss';
+const SetDom2 = 'Viewlet.setDom2';
+const SetUid = 'Viewlet.setUid';
+
+const commandsToForward$5 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
+const render$c = widget => {
+  const commands = renderFull$4(widget.oldState, widget.newState);
+  const wrappedCommands = [];
+  const {
+    uid
+  } = widget.newState;
+  for (const command of commands) {
+    if (commandsToForward$5.includes(command[0])) {
+      wrappedCommands.push(command);
+    } else {
+      wrappedCommands.push(['Viewlet.send', uid, ...command]);
+    }
+  }
+  return wrappedCommands;
+};
+const add$8 = widget => {
+  return addWidget(widget, 'FindWidget', render$c);
+};
+const remove$7 = widget => {
+  return [['Viewlet.dispose', widget.newState.uid]];
+};
+const focusFindInput = editor => {
+  const widget = editor.widgets.find(widget => widget.id === Find);
+  if (!widget) {
+    return editor;
+  }
+  const {
+    uid
+  } = widget.newState;
+  const newState = {
+    ...widget.newState,
+    commands: [[FocusSelector, uid, `[name="${SearchValue}"]`]]
+  };
+  return updateWidget(editor, Find, newState);
+};
+const {
+  close: close$4,
+  focusCloseButton,
+  focusFind,
+  focusNext: focusNext$3,
+  focusNextElement,
+  focusNextMatchButton,
+  focusPrevious: focusPrevious$2,
+  focusPreviousElement,
+  focusPreviousMatchButton,
+  focusReplace,
+  focusReplaceAllButton,
+  focusReplaceButton,
+  focusToggleReplace,
+  handleBlur,
+  handleClickButton,
+  handleFocus,
+  handleInput: handleInput$1,
+  handleReplaceFocus,
+  handleReplaceInput,
+  handleToggleReplaceFocus,
+  replace,
+  replaceAll,
+  toggleMatchCase,
+  toggleMatchWholeWord,
+  togglePreserveCase,
+  toggleReplace,
+  toggleUseRegularExpression
+} = createFns(['close', 'focusCloseButton', 'focusFind', 'focusNext', 'focusNextMatchButton', 'focusPrevious', 'focusPreviousMatchButton', 'focusReplace', 'focusReplaceAllButton', 'focusReplaceButton', 'focusToggleReplace', 'handleBlur', 'handleClickButton', 'handleFocus', 'handleInput', 'handleReplaceFocus', 'handleReplaceInput', 'handleToggleReplaceFocus', 'replace', 'replaceAll', 'toggleMatchCase', 'toggleMatchWholeWord', 'toggleReplace', 'toggleUseRegularExpression', 'focusNextElement', 'focusPreviousElement', 'togglePreserveCase'], 'FindWidget', Find);
+
+const EditorFindWidget = {
+  __proto__: null,
+  add: add$8,
+  close: close$4,
+  focusCloseButton,
+  focusFind,
+  focusFindInput,
+  focusNext: focusNext$3,
+  focusNextElement,
+  focusNextMatchButton,
+  focusPrevious: focusPrevious$2,
+  focusPreviousElement,
+  focusPreviousMatchButton,
+  focusReplace,
+  focusReplaceAllButton,
+  focusReplaceButton,
+  focusToggleReplace,
+  handleBlur,
+  handleClickButton,
+  handleFocus,
+  handleInput: handleInput$1,
+  handleReplaceFocus,
+  handleReplaceInput,
+  handleToggleReplaceFocus,
+  remove: remove$7,
+  render: render$c,
+  replace,
+  replaceAll,
+  toggleMatchCase,
+  toggleMatchWholeWord,
+  togglePreserveCase,
+  toggleReplace,
+  toggleUseRegularExpression
+};
+
+const create$3 = () => {
+  const uid = create$8();
+  const widget = {
+    id: Find,
+    newState: {
+      commands: [],
+      editorUid: 0,
+      height: 0,
+      uid,
+      width: 0,
+      x: 0,
+      y: 0
+    },
+    oldState: {
+      commands: [],
+      editorUid: 0,
+      height: 0,
+      uid,
+      width: 0,
+      x: 0,
+      y: 0
+    }
+  };
+  return widget;
+};
+
+const getEditor = editorUid => {
+  const instance = get$7(editorUid);
+  if (!instance) {
+    throw new Error(`editor ${editorUid} not found`);
+  }
+  const {
+    newState
+  } = instance;
+  return newState;
+};
+
+const loadContent$2 = async (state, parentUid) => {
+  const {
+    uid
+  } = state;
+  const editor = getEditor(parentUid);
+  const {
+    height,
+    width,
+    x,
+    y
+  } = editor;
   await launch();
   await invoke$3('FindWidget.create', uid, x, y, width, height, parentUid);
   await invoke$3('FindWidget.loadContent', uid);
@@ -7973,6 +8805,10 @@ const newStateGenerator$3 = (state, parentUid) => {
   return loadContent$2(state, parentUid);
 };
 const openFind2 = async editor => {
+  const editorWithFocusedFind = focusFindInput(editor);
+  if (editorWithFocusedFind !== editor) {
+    return editorWithFocusedFind;
+  }
   const fullFocus = true;
   return addWidgetToEditor(Find, FindWidget, editor, create$3, newStateGenerator$3, fullFocus);
 };
@@ -8272,7 +9108,7 @@ const getNewSelections$2 = (selections, lines, getDelta) => {
     const line = lines[selectionEndRow];
     newSelections[i] = selectionStartRow;
     newSelections[i + 1] = selectionStartColumn;
-    if (selectionEndColumn >= line.length) {
+    if (selectionEndColumn >= getLineLength(line)) {
       newSelections[i + 2] = selectionEndRow + 1;
       newSelections[i + 3] = 0;
     } else {
@@ -8644,36 +9480,7 @@ const setLanguageId = async (editor, languageId, tokenizePath) => {
 };
 
 const setSelections = (editor, selections) => {
-  const {
-    maxLineY,
-    minLineY,
-    rowHeight
-  } = editor;
-  const startRowIndex = selections[0];
-  if (startRowIndex < minLineY) {
-    const deltaY = startRowIndex * rowHeight;
-    return {
-      ...editor,
-      deltaY,
-      maxLineY: startRowIndex + 1,
-      minLineY: startRowIndex,
-      selections
-    };
-  }
-  if (startRowIndex > maxLineY) {
-    const deltaY = startRowIndex * rowHeight;
-    return {
-      ...editor,
-      deltaY,
-      maxLineY: startRowIndex + 1,
-      minLineY: startRowIndex,
-      selections
-    };
-  }
-  return {
-    ...editor,
-    selections
-  };
+  return scheduleSelections(editor, selections);
 };
 
 const setText = (editor, text) => {
@@ -8735,26 +9542,6 @@ const create$1 = () => {
   return widget;
 };
 
-const launchHoverWorker = async () => {
-  const name = 'Hover Worker';
-  const url = 'hoverWorkerMain.js';
-  const intializeCommand = 'Hover.initialize';
-  const rpc = await launchWorker(name, url, intializeCommand);
-  return rpc;
-};
-
-const state$2 = {};
-const getOrCreate$1 = () => {
-  if (!state$2.workerPromise) {
-    state$2.workerPromise = launchHoverWorker();
-  }
-  return state$2.workerPromise;
-};
-const invoke$2 = async (method, ...params) => {
-  const worker = await getOrCreate$1();
-  return await worker.invoke(method, ...params);
-};
-
 const newStateGenerator$1 = async (state, parentUid) => {
   const {
     height,
@@ -8816,27 +9603,7 @@ const create = () => {
       y: 0
     }
   };
-  return widget;
-};
-
-const launchSourceActionWorker = async () => {
-  const name = 'Source Action Worker';
-  const url = 'sourceActionWorkerMain.js';
-  const intializeCommand = 'SourceActions.initialize';
-  const rpc = await launchWorker(name, url, intializeCommand);
-  return rpc;
-};
-
-const state$1 = {};
-const getOrCreate = () => {
-  if (!state$1.workerPromise) {
-    state$1.workerPromise = launchSourceActionWorker();
-  }
-  return state$1.workerPromise;
-};
-const invoke$1 = async (method, ...params) => {
-  const worker = await getOrCreate();
-  return await worker.invoke(method, ...params);
+  return widget;
 };
 
 const newStateGenerator = async (state, parentUid) => {
@@ -9094,7 +9861,7 @@ const createDeleteEdit = (rowIndex, columnIndex, text) => {
       columnIndex: columnIndex + text.length,
       rowIndex
     },
-    inserted: [],
+    inserted: [''],
     origin: ToggleBlockComment$1,
     start: {
       columnIndex,
@@ -9165,7 +9932,7 @@ const getBlockCommentEdits = (editor, blockComment) => {
       endColumnIndex -= whitespaceAtEnd[0].length;
     }
     const change1 = {
-      deleted: [],
+      deleted: [''],
       end: {
         columnIndex: startColumnIndex,
         rowIndex
@@ -9178,7 +9945,7 @@ const getBlockCommentEdits = (editor, blockComment) => {
       }
     };
     const change2 = {
-      deleted: [],
+      deleted: [''],
       end: {
         columnIndex: endColumnIndex + blockCommentStart.length,
         rowIndex
@@ -9246,6 +10013,15 @@ const toggleBlockComment = async editor => {
   return scheduleDocument(editor, edits);
 };
 
+const toggleBreakpoint = editor => {
+  const [rowIndex] = editor.selections;
+  const breakPoints = editor.breakPoints.includes(rowIndex) ? editor.breakPoints.filter(breakPoint => breakPoint !== rowIndex) : [...editor.breakPoints, rowIndex];
+  return {
+    ...editor,
+    breakPoints
+  };
+};
+
 const getLineComment = async editor => {
   const languageConfiguration = await getLanguageConfiguration(editor);
   if (!languageConfiguration?.comments?.lineComment) {
@@ -9521,6 +10297,20 @@ const undo = state => {
   return scheduleDocumentAndCursorsSelectionIsUndo(newState, inverseChanges);
 };
 
+const unfold = editor => {
+  const {
+    foldingRanges = [],
+    primarySelectionIndex = 0,
+    selections
+  } = editor;
+  const rowIndex = selections[primarySelectionIndex];
+  const newRanges = removeRangeAt(foldingRanges, rowIndex);
+  if (newRanges === foldingRanges) {
+    return editor;
+  }
+  return updateLayout(editor, newRanges);
+};
+
 // @ts-ignore
 
 // const INDENT = '  '
@@ -9563,279 +10353,100 @@ const editorUnindent = editor => {
   //     let startRowIndex = selection.start.rowIndex
   //     const endRowIndex = selection.end.rowIndex
   //     if (startRowIndex === previousRowIndex) {
-  //       startRowIndex++
-  //     }
-  //     for (let i = startRowIndex; i <= endRowIndex; i++) {
-  //       indentLineMaybe(i)
-  //     }
-  //     let start = selection.start
-  //     let end = selection.end
-  //     if (editor.lines[start.rowIndex].startsWith(INDENT)) {
-  //       start = {
-  //         rowIndex: start.rowIndex,
-  //         columnIndex: Math.max(start.columnIndex - INDENT.length, 0),
-  //       }
-  //     }
-  //     if (editor.lines[end.rowIndex].startsWith(INDENT)) {
-  //       end = {
-  //         rowIndex: end.rowIndex,
-  //         columnIndex: Math.max(end.columnIndex - INDENT.length, 0),
-  //       }
-  //     }
-  //     cursorEdits.push(end)
-  //     selectionEdits.push({
-  //       start,
-  //       end,
-  //     })
-  //     previousRowIndex = endRowIndex
-  //   }
-  //   // @ts-ignore
-  //   Editor.scheduleDocumentAndCursorsAndSelections(editor, documentEdits, cursorEdits, selectionEdits)
-  //   return
-  // }
-  // const documentEdits = []
-  // const cursorEdits = []
-  // if (!editor.lines[editor.cursor.rowIndex].startsWith(INDENT)) {
-  //   return
-  // }
-  // // @ts-ignore
-  // documentEdits.push({
-  //   type: /* singleLineEdit */ 1,
-  //   rowIndex: editor.cursor.rowIndex,
-  //   inserted: '',
-  //   columnIndex: 2,
-  //   deleted: 2,
-  // })
-  // // @ts-ignore
-  // cursorEdits.push({
-  //   rowIndex: editor.cursor.rowIndex,
-  //   columnIndex: editor.cursor.columnIndex - 2,
-  // })
-  // // @ts-ignore
-  // Editor.scheduleDocumentAndCursors(editor, documentEdits, cursorEdits)
-  return editor;
-};
-// const editor = {
-//   textDocument: {
-//     lines: ['  line 1'],
-//   },
-//   cursor: {
-//     rowIndex: 0,
-//     columnIndex: 8,
-//   },
-//   selections: [
-//     {
-//       start: {
-//         rowIndex: 0,
-//         columnIndex: 0,
-//       },
-//       end: {
-//         rowIndex: 0,
-//         columnIndex: 8,
-//       },
-//     },
-//   ],
-//   tokenizer: TokenizePlainText,
-// }
-// editorUnindent(editor)
-
-// editor.lines //?
-
-const isFunctional = widgetId => {
-  switch (widgetId) {
-    case Message:
-    case ColorPicker$1:
-    case Completion:
-    case Find:
-    case Hover:
-    case Rename$1:
-    case SourceAction$1:
-      return true;
-    default:
-      return false;
-  }
-};
-const addWidget = (widget, id, render) => {
-  const commands = render(widget);
-  // TODO how to generate a unique integer id
-  // that doesn't collide with ids created in renderer worker?
-  // @ts-ignore
-  const {
-    uid
-  } = widget.newState;
-  const allCommands = [];
-  allCommands.push(['Viewlet.createFunctionalRoot', id, uid, isFunctional(widget.id)]);
-  allCommands.push(...commands);
-  if (isFunctional(widget.id)) {
-    allCommands.push(['Viewlet.appendToBody', uid]);
-  } else {
-    allCommands.push(['Viewlet.send', uid, 'appendWidget']);
-  }
-  const focusCommandIndex = allCommands.findIndex(command => {
-    return command[2] === 'focus' || command[0] === 'Viewlet.focusSelector';
-  });
-  // TODO have separate rendering functions, e.g.
-  // 1. renderDom
-  // 2. renderAriaAnnouncement
-  // 3. renderFocus
-  // to ensure that focus is always after the element is added to the DOM
-  if (focusCommandIndex !== -1) {
-    const command = allCommands[focusCommandIndex];
-    allCommands.splice(focusCommandIndex, 1);
-    allCommands.push(command);
-  }
-  return allCommands;
-};
-
-const getWidgetInvoke = widgetId => {
-  switch (widgetId) {
-    case ColorPicker$1:
-      return invoke$9;
-    case Completion:
-      return invoke$4;
-    case Find:
-      return invoke$3;
-    case Hover:
-      return invoke$2;
-    case Rename$1:
-      return invoke$5;
-    case SourceAction$1:
-      return invoke$1;
-    default:
-      return undefined;
-  }
-};
-
-const Close = 'Close';
-
-const updateWidget = (editor, widgetId, newState) => {
-  // TODO avoid closure
-  const isWidget = widget => {
-    return widget.id === widgetId;
-  };
-  const childIndex = editor.widgets.findIndex(isWidget);
-  if (childIndex === -1) {
-    return editor;
-  }
-  // TODO scroll up/down if necessary
-  const childWidget = editor.widgets[childIndex];
-  const newWidget = {
-    ...childWidget,
-    newState,
-    oldState: childWidget.newState
-  };
-  const newWidgets = [...editor.widgets.slice(0, childIndex), newWidget, ...editor.widgets.slice(childIndex + 1)];
-  return {
-    ...editor,
-    widgets: newWidgets
-  };
-};
-
-const getEditorByWidgetUid = (widgetUid, widgetId) => {
-  for (const key of getKeys$2()) {
-    const editor = get$7(Number(key)).newState;
-    const widgets = editor.widgets || [];
-    for (const widget of widgets) {
-      if (widget.id === widgetId && widget.newState.uid === widgetUid) {
-        return editor;
-      }
-    }
-  }
-  return undefined;
-};
-const getEditor = (editorOrUid, widgetId) => {
-  if (editorOrUid && editorOrUid.widgets) {
-    return editorOrUid;
-  }
-  const instance = get$7(editorOrUid);
-  if (instance && instance.newState && instance.newState.widgets) {
-    return instance.newState;
-  }
-  return getEditorByWidgetUid(editorOrUid, widgetId);
-};
-const createFn = (key, name, widgetId) => {
-  const isWidget = widget => {
-    return widget.id === widgetId;
-  };
-  const isClose = args => {
-    return key === 'close' || key === 'handleClickButton' && args.includes(Close);
-  };
-  const fn = async (editorOrUid, ...args) => {
-    const editor = getEditor(editorOrUid, widgetId);
-    if (!editor) {
-      return editorOrUid;
-    }
-    const childIndex = editor.widgets.findIndex(isWidget);
-    if (childIndex === -1) {
-      return editor;
-    }
-    // TODO scroll up/down if necessary
-    const childWidget = editor.widgets[childIndex];
-    const state = childWidget.newState;
-    const {
-      uid
-    } = state;
-    const invoke = getWidgetInvoke(widgetId);
-    await invoke(`${name}.${key}`, uid, ...args);
-    const diff = await invoke(`${name}.diff2`, uid);
-    const commands = await invoke(`${name}.render2`, uid, diff);
-    const latest = get$7(editor.uid).newState;
-    if (isClose(args)) {
-      const newEditor = {
-        ...latest,
-        focused: true,
-        widgets: removeEditorWidget(latest.widgets, widgetId)
-      };
-      set$9(editor.uid, latest, newEditor);
-      return newEditor;
-    }
-    const newState = {
-      ...state,
-      commands
-    };
-    const newEditor = updateWidget(latest, widgetId, newState);
-    set$9(editor.uid, latest, newEditor);
-    return newEditor;
-  };
-  return fn;
-};
-const createFns = (keys, name, widgetId) => {
-  const fns = Object.create(null);
-  for (const key of keys) {
-    fns[key] = createFn(key, name, widgetId);
-  }
-  return fns;
+  //       startRowIndex++
+  //     }
+  //     for (let i = startRowIndex; i <= endRowIndex; i++) {
+  //       indentLineMaybe(i)
+  //     }
+  //     let start = selection.start
+  //     let end = selection.end
+  //     if (editor.lines[start.rowIndex].startsWith(INDENT)) {
+  //       start = {
+  //         rowIndex: start.rowIndex,
+  //         columnIndex: Math.max(start.columnIndex - INDENT.length, 0),
+  //       }
+  //     }
+  //     if (editor.lines[end.rowIndex].startsWith(INDENT)) {
+  //       end = {
+  //         rowIndex: end.rowIndex,
+  //         columnIndex: Math.max(end.columnIndex - INDENT.length, 0),
+  //       }
+  //     }
+  //     cursorEdits.push(end)
+  //     selectionEdits.push({
+  //       start,
+  //       end,
+  //     })
+  //     previousRowIndex = endRowIndex
+  //   }
+  //   // @ts-ignore
+  //   Editor.scheduleDocumentAndCursorsAndSelections(editor, documentEdits, cursorEdits, selectionEdits)
+  //   return
+  // }
+  // const documentEdits = []
+  // const cursorEdits = []
+  // if (!editor.lines[editor.cursor.rowIndex].startsWith(INDENT)) {
+  //   return
+  // }
+  // // @ts-ignore
+  // documentEdits.push({
+  //   type: /* singleLineEdit */ 1,
+  //   rowIndex: editor.cursor.rowIndex,
+  //   inserted: '',
+  //   columnIndex: 2,
+  //   deleted: 2,
+  // })
+  // // @ts-ignore
+  // cursorEdits.push({
+  //   rowIndex: editor.cursor.rowIndex,
+  //   columnIndex: editor.cursor.columnIndex - 2,
+  // })
+  // // @ts-ignore
+  // Editor.scheduleDocumentAndCursors(editor, documentEdits, cursorEdits)
+  return editor;
 };
+// const editor = {
+//   textDocument: {
+//     lines: ['  line 1'],
+//   },
+//   cursor: {
+//     rowIndex: 0,
+//     columnIndex: 8,
+//   },
+//   selections: [
+//     {
+//       start: {
+//         rowIndex: 0,
+//         columnIndex: 0,
+//       },
+//       end: {
+//         rowIndex: 0,
+//         columnIndex: 8,
+//       },
+//     },
+//   ],
+//   tokenizer: TokenizePlainText,
+// }
+// editorUnindent(editor)
 
-const AppendToBody = 'Viewlet.appendToBody';
-const Focus = 'focus';
-const FocusSelector = 'Viewlet.focusSelector';
-const RegisterEventListeners = 'Viewlet.registerEventListeners';
-const SetSelectionByName = 'Viewlet.setSelectionByName';
-const SetValueByName = 'Viewlet.setValueByName';
-const SetFocusContext = 'Viewlet.setFocusContext';
-const SetBounds = 'setBounds';
-const SetBounds2 = 'Viewlet.setBounds';
-const SetCss = 'Viewlet.setCss';
-const SetDom2 = 'Viewlet.setDom2';
-const SetUid = 'Viewlet.setUid';
+// editor.lines //?
 
-const renderFull$4 = (oldState, newState) => {
+const renderFull$3 = (oldState, newState) => {
   const commands = [...newState.commands];
   // @ts-ignore
   newState.commands = [];
   return commands;
 };
 
-const commandsToForward$5 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
-const render$c = widget => {
-  const commands = renderFull$4(widget.oldState, widget.newState);
+const commandsToForward$4 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
+const render$b = widget => {
+  const commands = renderFull$3(widget.oldState, widget.newState);
   const wrappedCommands = [];
   const {
     uid
   } = widget.newState;
   for (const command of commands) {
-    if (commandsToForward$5.includes(command[0])) {
+    if (commandsToForward$4.includes(command[0])) {
       wrappedCommands.push(command);
     } else {
       wrappedCommands.push(['Viewlet.send', uid, ...command]);
@@ -9843,20 +10454,20 @@ const render$c = widget => {
   }
   return wrappedCommands;
 };
-const add$8 = widget => {
-  return addWidget(widget, 'EditorCompletion', render$c);
+const add$7 = widget => {
+  return addWidget(widget, 'EditorCompletion', render$b);
 };
-const remove$7 = widget => {
+const remove$6 = widget => {
   return [['Viewlet.dispose', widget.newState.uid]];
 };
 const {
-  close: close$4,
+  close: close$3,
   closeDetails: closeDetails$1,
   focusFirst: focusFirst$1,
   focusIndex: focusIndex$2,
   focusLast: focusLast$1,
-  focusNext: focusNext$3,
-  focusPrevious: focusPrevious$2,
+  focusNext: focusNext$2,
+  focusPrevious: focusPrevious$1,
   handleEditorBlur,
   handleEditorClick,
   handleEditorDeleteLeft: handleEditorDeleteLeft$1,
@@ -9871,14 +10482,14 @@ const {
 
 const EditorCompletionWidget = {
   __proto__: null,
-  add: add$8,
-  close: close$4,
+  add: add$7,
+  close: close$3,
   closeDetails: closeDetails$1,
   focusFirst: focusFirst$1,
   focusIndex: focusIndex$2,
   focusLast: focusLast$1,
-  focusNext: focusNext$3,
-  focusPrevious: focusPrevious$2,
+  focusNext: focusNext$2,
+  focusPrevious: focusPrevious$1,
   handleEditorBlur,
   handleEditorClick,
   handleEditorDeleteLeft: handleEditorDeleteLeft$1,
@@ -9886,106 +10497,13 @@ const EditorCompletionWidget = {
   handlePointerDown,
   handleWheel: handleWheel$1,
   openDetails,
-  remove: remove$7,
-  render: render$c,
+  remove: remove$6,
+  render: render$b,
   selectCurrent: selectCurrent$1,
   selectIndex: selectIndex$1,
   toggleDetails: toggleDetails$1
 };
 
-const renderFull$3 = (oldState, newState) => {
-  const commands = [...newState.commands];
-  // @ts-ignore
-  newState.commands = [];
-  return commands;
-};
-
-const commandsToForward$4 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
-const render$b = widget => {
-  const commands = renderFull$3(widget.oldState, widget.newState);
-  const wrappedCommands = [];
-  const {
-    uid
-  } = widget.newState;
-  for (const command of commands) {
-    if (commandsToForward$4.includes(command[0])) {
-      wrappedCommands.push(command);
-    } else {
-      wrappedCommands.push(['Viewlet.send', uid, ...command]);
-    }
-  }
-  return wrappedCommands;
-};
-const add$7 = widget => {
-  return addWidget(widget, 'FindWidget', render$b);
-};
-const remove$6 = widget => {
-  return [['Viewlet.dispose', widget.newState.uid]];
-};
-const {
-  close: close$3,
-  focusCloseButton,
-  focusFind,
-  focusNext: focusNext$2,
-  focusNextElement,
-  focusNextMatchButton,
-  focusPrevious: focusPrevious$1,
-  focusPreviousElement,
-  focusPreviousMatchButton,
-  focusReplace,
-  focusReplaceAllButton,
-  focusReplaceButton,
-  focusToggleReplace,
-  handleBlur,
-  handleClickButton,
-  handleFocus,
-  handleInput: handleInput$1,
-  handleReplaceFocus,
-  handleReplaceInput,
-  handleToggleReplaceFocus,
-  replace,
-  replaceAll,
-  toggleMatchCase,
-  toggleMatchWholeWord,
-  togglePreserveCase,
-  toggleReplace,
-  toggleUseRegularExpression
-} = createFns(['close', 'focusCloseButton', 'focusFind', 'focusNext', 'focusNextMatchButton', 'focusPrevious', 'focusPreviousMatchButton', 'focusReplace', 'focusReplaceAllButton', 'focusReplaceButton', 'focusToggleReplace', 'handleBlur', 'handleClickButton', 'handleFocus', 'handleInput', 'handleReplaceFocus', 'handleReplaceInput', 'handleToggleReplaceFocus', 'replace', 'replaceAll', 'toggleMatchCase', 'toggleMatchWholeWord', 'toggleReplace', 'toggleUseRegularExpression', 'focusNextElement', 'focusPreviousElement', 'togglePreserveCase'], 'FindWidget', Find);
-
-const EditorFindWidget = {
-  __proto__: null,
-  add: add$7,
-  close: close$3,
-  focusCloseButton,
-  focusFind,
-  focusNext: focusNext$2,
-  focusNextElement,
-  focusNextMatchButton,
-  focusPrevious: focusPrevious$1,
-  focusPreviousElement,
-  focusPreviousMatchButton,
-  focusReplace,
-  focusReplaceAllButton,
-  focusReplaceButton,
-  focusToggleReplace,
-  handleBlur,
-  handleClickButton,
-  handleFocus,
-  handleInput: handleInput$1,
-  handleReplaceFocus,
-  handleReplaceInput,
-  handleToggleReplaceFocus,
-  remove: remove$6,
-  render: render$b,
-  replace,
-  replaceAll,
-  toggleMatchCase,
-  toggleMatchWholeWord,
-  togglePreserveCase,
-  toggleReplace,
-  toggleUseRegularExpression
-};
-
 const getTextDocument = editor => {
   return {
     documentId: editor.id || editor.uid,
@@ -10360,7 +10878,7 @@ const renderHover = (oldState, newState) => {
 
 const commandsToForward$3 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
 const render$9 = widget => {
-  const commands = renderFull$4(widget.oldState, widget.newState);
+  const commands = renderFull$3(widget.oldState, widget.newState);
   const wrappedCommands = [];
   const {
     uid
@@ -10421,7 +10939,7 @@ const removeWidget = widget => {
 
 const commandsToForward$2 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
 const render$8 = widget => {
-  const commands = renderFull$4(widget.oldState, widget.newState);
+  const commands = renderFull$3(widget.oldState, widget.newState);
   const wrappedCommands = [];
   const {
     uid
@@ -10488,7 +11006,7 @@ const executeWidgetCommand = async (editor, name, method, _uid, widgetId, ...par
   const isWidget = widget => {
     return widget.id === widgetId;
   };
-  const latestEditor = getEditor$1(editor.uid);
+  const latestEditor = getEditor(editor.uid);
   const childIndex1 = latestEditor.widgets.findIndex(isWidget);
   if (childIndex1 === -1) {
     return latestEditor;
@@ -10569,54 +11087,54 @@ const FocusEditorCodeGenerator = 52;
 const FocusColorPicker = 41;
 
 const getPositionAtCursor = editorUid => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   return getPositionAtCursor$1(editor);
 };
 const getUri = editorUid => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   return editor.uri;
 };
 const getLanguageId = editorUid => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   return editor.languageId;
 };
 const getOffsetAtCursor = editorUid => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   return getOffsetAtCursor$1(editor);
 };
 const getWordAt = (editorUid, rowIndex, columnIndex) => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const {
     word
   } = getWordAt$1(editor, rowIndex, columnIndex);
   return word;
 };
 const getWordAtOffset2 = editorUid => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const word = getWordAtOffset(editor);
   return word;
 };
 const getWordBefore2 = (editorUid, rowIndex, columnIndex) => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const word = getWordBefore(editor, rowIndex, columnIndex);
   return word;
 };
 const getLines2 = editorUid => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const {
     lines
   } = editor;
   return lines;
 };
 const getSelections2 = editorUid => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const {
     selections
   } = editor;
   return selections;
 };
 const setSelections2 = async (editorUid, selections) => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const newEditor = {
     ...editor,
     selections
@@ -10625,7 +11143,7 @@ const setSelections2 = async (editorUid, selections) => {
   set$9(editorUid, editor, newEditorWithDerivedState);
 };
 const closeWidget2 = async (editorUid, widgetId, widgetName, unsetAdditionalFocus$1) => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const invoke = getWidgetInvoke(widgetId);
   const {
     widgets
@@ -10653,7 +11171,7 @@ const closeFind2 = async editorUid => {
   await closeWidget2(editorUid, Find, 'FindWidget', 0);
 };
 const applyEdits2 = async (editorUid, edits) => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const newEditor = await applyEdit(editor, edits);
   const newEditorWithDerivedState = await updateDerivedState(editor, newEditor);
   set$9(editorUid, editor, newEditorWithDerivedState);
@@ -10663,7 +11181,7 @@ const getSourceActions = async editorUid => {
   return actions;
 };
 const getDiagnostics$1 = async editorUid => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const {
     diagnostics
   } = editor;
@@ -10707,6 +11225,10 @@ const getKeyBindings = () => {
     command: 'FindWidget.focusNext',
     key: Enter,
     when: FocusFindWidget
+  }, {
+    command: 'FindWidget.focusPrevious',
+    key: Shift | Enter,
+    when: FocusFindWidget
   }, {
     command: 'FindWidget.preventDefaultBrowserFind',
     key: CtrlCmd | KeyF,
@@ -10788,7 +11310,7 @@ const getKeyBindings = () => {
     key: Enter,
     when: FocusEditorCompletions
   }, {
-    command: 'EditorCompletion.close',
+    command: 'Editor.closeCompletion',
     key: Escape,
     when: FocusEditorCompletions
   }, {
@@ -10811,6 +11333,14 @@ const getKeyBindings = () => {
     command: 'Editor.cursorWordLeft',
     key: CtrlCmd | LeftArrow,
     when: FocusEditorText
+  }, {
+    command: 'Editor.cursorDocumentEnd',
+    key: CtrlCmd | End,
+    when: FocusEditorText
+  }, {
+    command: 'Editor.cursorDocumentStart',
+    key: CtrlCmd | Home,
+    when: FocusEditorText
   }, {
     command: 'Editor.deleteWordPartLeft',
     key: Alt$1 | Backspace,
@@ -10851,6 +11381,10 @@ const getKeyBindings = () => {
     command: 'Editor.indentLess',
     key: CtrlCmd | BracketLeft,
     when: FocusEditorText
+  }, {
+    command: 'Editor.fold',
+    key: CtrlCmd | Shift | BracketLeft,
+    when: FocusEditorText
   }, {
     command: 'Editor.closeFind',
     key: Escape,
@@ -10875,6 +11409,10 @@ const getKeyBindings = () => {
     command: 'Editor.indentMore',
     key: CtrlCmd | BracketRight,
     when: FocusEditorText
+  }, {
+    command: 'Editor.unfold',
+    key: CtrlCmd | Shift | BracketRight,
+    when: FocusEditorText
   }, {
     command: 'Editor.selectCharacterLeft',
     key: Shift | LeftArrow,
@@ -10903,6 +11441,10 @@ const getKeyBindings = () => {
     command: 'Editor.deleteAllRight',
     key: CtrlCmd | Shift | Delete$1,
     when: FocusEditorText
+  }, {
+    command: 'Editor.deleteLine',
+    key: CtrlCmd | Shift | KeyK,
+    when: FocusEditorText
   }, {
     command: 'Editor.cancelSelection',
     key: Escape,
@@ -10927,6 +11469,10 @@ const getKeyBindings = () => {
     command: 'Editor.cursorDown',
     key: DownArrow,
     when: FocusEditorText
+  }, {
+    command: 'Editor.cursorPageDown',
+    key: PageDown,
+    when: FocusEditorText
   }, {
     command: 'Editor.deleteLeft',
     key: Backspace,
@@ -10959,6 +11505,10 @@ const getKeyBindings = () => {
     command: 'Editor.openRename',
     key: F2,
     when: FocusEditorText
+  }, {
+    command: 'Editor.toggleBreakpoint',
+    key: F9,
+    when: FocusEditorText
   }, {
     command: 'EditorRename.accept',
     key: Enter,
@@ -10979,6 +11529,10 @@ const getKeyBindings = () => {
     command: 'Editor.toggleComment',
     key: CtrlCmd | Slash$1,
     when: FocusEditorText
+  }, {
+    command: 'Editor.toggleBlockComment',
+    key: Alt$1 | Shift | KeyA,
+    when: FocusEditorText
   }, {
     command: 'Editor.copy',
     key: CtrlCmd | KeyC,
@@ -11013,11 +11567,11 @@ const getKeyBindings = () => {
     when: FocusEditorText
   }, {
     command: 'Editor.addCursorAbove',
-    key: Alt$1 | Shift | UpArrow,
+    key: Alt$1 | CtrlCmd | UpArrow,
     when: FocusEditorText
   }, {
     command: 'Editor.addCursorBelow',
-    key: Alt$1 | Shift | DownArrow,
+    key: Alt$1 | CtrlCmd | DownArrow,
     when: FocusEditorText
   }, {
     command: 'Editor.findAllReferences',
@@ -11134,6 +11688,15 @@ const getProblems = async () => {
 
 const getQuickPickMenuEntries = () => {
   return [{
+    id: 'Editor.fold',
+    label: fold()
+  }, {
+    id: 'Editor.unfold',
+    label: unfold$1()
+  }, {
+    id: 'Editor.deleteLine',
+    label: deleteLine()
+  }, {
     id: 'Editor.format',
     label: formatDocument()
   }, {
@@ -11180,6 +11743,9 @@ const getQuickPickMenuEntries = () => {
   }, {
     id: 'Editor.toggleBlockComment',
     label: toggleBlockComment$1()
+  }, {
+    id: 'Editor.toggleBreakpoint',
+    label: toggleBreakpoint$1()
   }, {
     id: 'Editor.openColorPicker',
     label: editorOpenColorPicker()
@@ -11205,7 +11771,7 @@ const getQuickPickMenuEntries = () => {
 };
 
 const getSelections = editorUid => {
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const {
     selections
   } = editor;
@@ -11214,7 +11780,7 @@ const getSelections = editorUid => {
 
 const getText = editorUid => {
   number(editorUid);
-  const editor = getEditor$1(editorUid);
+  const editor = getEditor(editorUid);
   const {
     lines
   } = editor;
@@ -11736,6 +12302,13 @@ const registerListener = (listenerType, rpcId) => {
   registerListener$1(listenerType, rpcId);
 };
 
+const renderAdditionalFocusContext$1 = (oldState, newState) => {
+  if (newState.additionalFocus) {
+    return ['Viewlet.setAdditionalFocus', newState.uid, newState.additionalFocus];
+  }
+  return ['Viewlet.unsetAdditionalFocus', newState.uid, oldState.additionalFocus];
+};
+
 const getCss = (uid, rowHeight, scrollBarHeight, scrollBarTop, scrollBarWidth, scrollBarLeft) => {
   const editorSelector = `.Editor[data-uid="${uid}"]`;
   return `${editorSelector} {
@@ -12196,7 +12769,6 @@ const getEditorRowsVirtualDom = (textInfos, differences, lineNumbers = true, hig
     className: 'EditorRows',
     onMouseDown: HandleMouseDown,
     onPointerDown: HandlePointerDown,
-    onWheel: HandleWheel,
     type: Div
   }, ...rowsDom];
 };
@@ -12284,16 +12856,25 @@ const getEditorContentVirtualDom = ({
     className: 'EditorContent',
     onKeyUp: HandleKeyUp,
     onMouseMove: HandleMouseMove,
+    onWheel: HandleWheel,
     type: Div
   }, ...getEditorInputVirtualDom(), ...getEditorLayersVirtualDom(selectionInfos, textInfos, differences, lineNumbers, highlightedLine, cursorInfos, diagnostics), ...getEditorScrollBarDiagnosticsVirtualDom(scrollBarDiagnostics), ...getScrollBarVirtualDom()];
 };
 
 const getGutterInfoVirtualDom = gutterInfo => {
+  const isBreakpoint = typeof gutterInfo === 'object' && gutterInfo.isBreakpoint;
+  const lineNumber = typeof gutterInfo === 'object' ? gutterInfo.lineNumber : gutterInfo;
+  const label = `Breakpoint on line ${lineNumber}`;
   return [{
+    ...(isBreakpoint && {
+      ariaLabel: label,
+      style: 'color:var(--DebugIconBreakpointForeground,#e51400)',
+      title: label
+    }),
     childCount: 1,
-    className: 'LineNumber',
+    className: isBreakpoint ? 'LineNumber LineNumberBreakpoint' : 'LineNumber',
     type: Span
-  }, text(gutterInfo)];
+  }, text(isBreakpoint ? '●' : lineNumber)];
 };
 const getEditorGutterVirtualDom$1 = gutterInfos => {
   const dom = gutterInfos.flatMap(getGutterInfoVirtualDom);
@@ -12309,7 +12890,23 @@ const getEditorGutterVirtualDom = gutterInfos => {
   }, ...gutterDom];
 };
 
+const getGutterInfos = (minLineY, maxLineY, breakPoints, showLineNumbers = true, lineIndices) => {
+  const gutterInfos = [];
+  const rows = lineIndices || Array.from({
+    length: maxLineY - minLineY
+  }, (_, index) => minLineY + index);
+  for (const rowIndex of rows) {
+    const lineNumber = rowIndex + 1;
+    gutterInfos.push(breakPoints.includes(rowIndex) ? {
+      isBreakpoint: true,
+      lineNumber
+    } : showLineNumbers ? lineNumber : '');
+  }
+  return gutterInfos;
+};
+
 const getEditorVirtualDom = ({
+  breakPoints = [],
   cursorInfos = [],
   diagnostics = [],
   differences,
@@ -12317,10 +12914,13 @@ const getEditorVirtualDom = ({
   highlightedLine = -1,
   lineNumbers = true,
   loadError = '',
+  maxLineY = 0,
+  minLineY = 0,
   scrollBarDiagnostics = [],
   selectionInfos = [],
   textInfos,
-  uid
+  uid,
+  visibleLineIndices
 }) => {
   if (loadError) {
     return [{
@@ -12339,9 +12939,11 @@ const getEditorVirtualDom = ({
       type: Div
     }, text(loadError)];
   }
-  const gutterDom = lineNumbers ? getEditorGutterVirtualDom(gutterInfos) : [];
+  const visibleGutterInfos = breakPoints.length > 0 || visibleLineIndices ? getGutterInfos(minLineY, maxLineY, breakPoints, lineNumbers, visibleLineIndices) : gutterInfos;
+  const showGutter = lineNumbers || breakPoints.length > 0;
+  const gutterDom = showGutter ? getEditorGutterVirtualDom(visibleGutterInfos) : [];
   return [{
-    childCount: lineNumbers ? 2 : 1,
+    childCount: showGutter ? 2 : 1,
     className: 'Viewlet Editor',
     'data-uid': uid,
     onContextMenu: HandleContextMenu,
@@ -12370,12 +12972,16 @@ const set = (uid, dom) => {
 const getDom = state => {
   const {
     initial,
-    textInfos
+    textInfos,
+    visualDecorations = []
   } = state;
   if (initial && textInfos.length === 0) {
     return [];
   }
-  return getEditorVirtualDom(state);
+  return getEditorVirtualDom({
+    ...state,
+    diagnostics: visualDecorations
+  });
 };
 const renderIncremental = (oldState, newState) => {
   const oldDom = oldState.initial ? getDom(oldState) : get(newState.uid) || getDom(oldState);
@@ -12390,6 +12996,8 @@ const renderIncremental = (oldState, newState) => {
 
 const getRenderer = diffType => {
   switch (diffType) {
+    case RenderAdditionalFocusContext:
+      return renderAdditionalFocusContext$1;
     case RenderCss:
       return renderCss$1;
     case RenderFocus:
@@ -12446,13 +13054,13 @@ const renderLines = {
     newState.differences = differences;
     const {
       highlightedLine,
-      minLineY
+      visibleLineIndices
     } = newState;
-    const relativeLine = highlightedLine - minLineY;
+    const relativeLine = visibleLineIndices.indexOf(highlightedLine);
     const dom = getEditorRowsVirtualDom$1(textInfos, differences, true, relativeLine);
     return [/* method */'setText', dom];
   },
-  isEqual: (oldState, newState) => oldState.lines === newState.lines && oldState.tokenizerId === newState.tokenizerId && oldState.minLineY === newState.minLineY && oldState.decorations === newState.decorations && oldState.embeds === newState.embeds && oldState.deltaX === newState.deltaX && oldState.width === newState.width && oldState.highlightedLine === newState.highlightedLine && oldState.debugEnabled === newState.debugEnabled
+  isEqual: (oldState, newState) => oldState.lines === newState.lines && oldState.foldingRanges === newState.foldingRanges && oldState.tokenizerId === newState.tokenizerId && oldState.minLineY === newState.minLineY && oldState.decorations === newState.decorations && oldState.embeds === newState.embeds && oldState.deltaX === newState.deltaX && oldState.width === newState.width && oldState.highlightedLine === newState.highlightedLine && oldState.debugEnabled === newState.debugEnabled
 };
 const renderSelections = {
   apply: (oldState, newState) => {
@@ -12479,13 +13087,8 @@ const renderFocusContext = {
   isEqual: (oldState, newState) => oldState.focus === newState.focus
 };
 const renderAdditionalFocusContext = {
-  apply(oldState, newState) {
-    if (newState.additionalFocus) {
-      return ['Viewlet.setAdditionalFocus', newState.uid, newState.additionalFocus];
-    }
-    return ['viewlet.unsetAdditionalFocus', newState.uid, newState.additionalFocus];
-  },
-  isEqual: (oldState, newState) => oldState.additionalFocus === newState.additionalFocus
+  apply: renderAdditionalFocusContext$1,
+  isEqual: isEqual$4
 };
 const renderDecorations = {
   apply(oldState, newState) {
@@ -12497,21 +13100,20 @@ const renderDecorations = {
 const renderGutterInfo = {
   apply(oldState, newState) {
     const {
+      breakPoints,
       lineNumbers,
       maxLineY,
-      minLineY
+      minLineY,
+      visibleLineIndices
     } = newState;
-    if (!lineNumbers) {
-      return [];
-    }
-    const gutterInfos = [];
-    for (let i = minLineY; i < maxLineY; i++) {
-      gutterInfos.push(i + 1);
+    if (!lineNumbers && breakPoints.length === 0) {
+      return ['renderGutter', []];
     }
+    const gutterInfos = getGutterInfos(minLineY, maxLineY, breakPoints, lineNumbers, visibleLineIndices);
     const dom = getEditorGutterVirtualDom$1(gutterInfos);
     return ['renderGutter', dom];
   },
-  isEqual: (oldState, newState) => oldState.lineNumbers === newState.lineNumbers && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY
+  isEqual: (oldState, newState) => oldState.breakPoints === newState.breakPoints && oldState.foldingRanges === newState.foldingRanges && oldState.lineNumbers === newState.lineNumbers && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY
 };
 const renderWidgets = {
   apply: renderWidgets$1,
@@ -12737,6 +13339,7 @@ const commandMap = {
   'Editor.cancelSelection': wrapCommand(cancelSelection),
   'Editor.closeCodeGenerator': wrapCommand(closeCodeGenerator),
   'Editor.closeColorPicker': wrapCommand(closeColorPicker),
+  'Editor.closeCompletion': wrapCommand(closeCompletion),
   'Editor.closeFind': wrapCommand(closeFind),
   'Editor.closeFind2': closeFind2,
   'Editor.closeRename': wrapCommand(closeRename),
@@ -12753,10 +13356,13 @@ const commandMap = {
   'Editor.create2': createEditor2,
   'Editor.cursorCharacterLeft': wrapCommand(cursorCharacterLeft),
   'Editor.cursorCharacterRight': wrapCommand(cursorCharacterRight),
+  'Editor.cursorDocumentEnd': wrapCommand(cursorDocumentEnd),
+  'Editor.cursorDocumentStart': wrapCommand(cursorDocumentStart),
   'Editor.cursorDown': wrapCommand(cursorDown),
   'Editor.cursorEnd': wrapCommand(cursorEnd),
   'Editor.cursorHome': wrapCommand(cursorHome),
   'Editor.cursorLeft': wrapCommand(cursorCharacterLeft),
+  'Editor.cursorPageDown': wrapCommand(cursorPageDown),
   'Editor.cursorRight': wrapCommand(cursorCharacterRight),
   'Editor.cursorSet': wrapCommand(cursorSet),
   'Editor.cursorUp': wrapCommand(cursorUp),
@@ -12772,6 +13378,7 @@ const commandMap = {
   'Editor.deleteCharacterRight': wrapCommand(deleteCharacterRight),
   'Editor.deleteHorizontalRight': wrapCommand(editorDeleteHorizontalRight),
   'Editor.deleteLeft': wrapCommand(deleteCharacterLeft),
+  'Editor.deleteLine': wrapCommand(deleteLine$1),
   'Editor.deleteRight': wrapCommand(deleteCharacterRight),
   'Editor.deleteWordLeft': wrapCommand(deleteWordLeft),
   'Editor.deleteWordPartLeft': wrapCommand(deleteWordPartLeft),
@@ -12781,6 +13388,7 @@ const commandMap = {
   'Editor.dispose': disposeEditor,
   'Editor.executeWidgetCommand': wrapCommand(executeWidgetCommand),
   'Editor.findAllReferences': wrapCommand(findAllReferences$1),
+  'Editor.fold': wrapCommand(fold$1),
   'Editor.format': wrapCommand(format),
   'Editor.getCommandIds': getCommandIds,
   'Editor.getDiagnostics': getDiagnostics$1,
@@ -12903,20 +13511,22 @@ const commandMap = {
   'Editor.tabCompletion': wrapCommand(tabCompletion),
   'Editor.terminate': terminate,
   'Editor.toggleBlockComment': wrapCommand(toggleBlockComment),
+  'Editor.toggleBreakpoint': wrapCommand(toggleBreakpoint),
   'Editor.toggleComment': wrapCommand(toggleComment),
   'Editor.toggleLineComment': wrapCommand(editorToggleLineComment),
   'Editor.type': wrapCommand(type),
   'Editor.typeWithAutoClosing': wrapCommand(typeWithAutoClosing),
   'Editor.undo': wrapCommand(undo),
+  'Editor.unfold': wrapCommand(unfold),
   'Editor.unIndent': wrapCommand(editorUnindent),
   'Editor.updateDebugInfo': updateDebugInfo,
   'Editor.updateDiagnostics': wrapCommand(updateDiagnostics),
-  'EditorCompletion.close': close$4,
+  'EditorCompletion.close': close$3,
   'EditorCompletion.closeDetails': closeDetails$1,
   'EditorCompletion.focusFirst': focusFirst$1,
   'EditorCompletion.focusIndex': focusIndex$2,
-  'EditorCompletion.focusNext': focusNext$3,
-  'EditorCompletion.focusPrevious': focusPrevious$2,
+  'EditorCompletion.focusNext': focusNext$2,
+  'EditorCompletion.focusPrevious': focusPrevious$1,
   'EditorCompletion.handleEditorBlur': handleEditorBlur,
   'EditorCompletion.handleEditorClick': handleEditorClick,
   'EditorCompletion.handleEditorDeleteLeft': handleEditorDeleteLeft$1,
@@ -12943,13 +13553,13 @@ const commandMap = {
   'EditorSourceAction.toggleDetails': toggleDetails,
   'EditorSourceActions.focusNext': focusNext$1,
   'ExtensionHostManagement.activateByEvent': activateByEvent,
-  'FindWidget.close': close$3,
+  'FindWidget.close': close$4,
   'FindWidget.focusCloseButton': focusCloseButton,
   'FindWidget.focusFind': focusFind,
-  'FindWidget.focusNext': focusNext$2,
+  'FindWidget.focusNext': focusNext$3,
   'FindWidget.focusNextElement': focusNextElement,
   'FindWidget.focusNextMatchButton': focusNextMatchButton,
-  'FindWidget.focusPrevious': focusPrevious$1,
+  'FindWidget.focusPrevious': focusPrevious$2,
   'FindWidget.focusPreviousElement': focusPreviousElement,
   'FindWidget.focusPreviousMatchButton': focusPreviousMatchButton,
   'FindWidget.focusReplace': focusReplace,
@@ -13317,7 +13927,7 @@ const EditorCompletionDetailWidget = {
 
 const commandsToForward = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
 const render$1 = widget => {
-  const commands = renderFull$4(widget.oldState, widget.newState);
+  const commands = renderFull$3(widget.oldState, widget.newState);
   const wrappedCommands = [];
   const {
     uid