@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/remote/browser/remoteExplorer.js

@@ -1,9 +1,10 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { OnPortForward, AutoTunnelSource, makeAddress } from '../../../services/remote/common/remoteExplorerService.js';
+import { OnPortForward, mapHasAddressLocalhostOrAllInterfaces, TunnelCloseReason, AutoTunnelSource, makeAddress } from '../../../services/remote/common/remoteExplorerService.js';
 import { OpenPortInPreviewAction, OpenPortInBrowserAction, TunnelPanel, openPreviewEnabledContext } from './tunnelView.js';
 import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
 import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { TunnelPrivacyId } from '../../../../platform/tunnel/common/tunnel.js';
 const VIEWLET_ID = 'workbench.view.remote';
 class OnAutoForwardedAction extends Disposable {
     constructor(notificationService, remoteExplorerService, openerService, externalOpenerService, tunnelService, hostService, logService, contextKeyService) {
@@ -130,6 +131,9 @@ class OnAutoForwardedAction extends Disposable {
             ));
             choices.unshift(this.elevateChoice(tunnel));
         }
+        if (tunnel.privacy === TunnelPrivacyId.Private && isWeb && this.tunnelService.canChangePrivacy) {
+            choices.push(this.makePublicChoice(tunnel));
+        }
         message += this.linkMessage();
         this.lastNotification = this.notificationService.prompt(Severity.Info, message, choices, { neverShowAgain: { id: 'remote.tunnelsView.autoForwardNeverShow', isSecondary: true } });
         this.lastShownPort = tunnel.tunnelRemotePort;
@@ -139,6 +143,23 @@ class OnAutoForwardedAction extends Disposable {
             this.lastShownPort = undefined;
         });
     }
+    makePublicChoice(tunnel) {
+        return {
+            label: ( nls.localize('remote.tunnelsView.makePublic', "Make Public")),
+            run: async () => {
+                const oldTunnelDetails = mapHasAddressLocalhostOrAllInterfaces(this.remoteExplorerService.tunnelModel.forwarded, tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
+                await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
+                return this.remoteExplorerService.forward({
+                    remote: { host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort },
+                    local: tunnel.tunnelLocalPort,
+                    name: oldTunnelDetails?.name,
+                    elevateIfNeeded: true,
+                    privacy: TunnelPrivacyId.Public,
+                    source: oldTunnelDetails?.source
+                });
+            }
+        };
+    }
     openBrowserChoice(tunnel) {
         const address = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
         return {
@@ -161,7 +182,7 @@ class OnAutoForwardedAction extends Disposable {
                 tunnel.tunnelRemotePort
             )),
             run: async () => {
-                await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort });
+                await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
                 const newTunnel = await this.remoteExplorerService.forward({
                     remote: { host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort },
                     local: tunnel.tunnelRemotePort,

package/dist/vscode/vs/workbench/contrib/remote/browser/tunnelView.js

@@ -18,7 +18,7 @@ import { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLa
 import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { MenuRegistry, MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { createAndFillInActionBarActions, createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
-import { TUNNEL_VIEW_ID, TunnelType, makeAddress, IRemoteExplorerService, TunnelEditId, parseAddress, mapHasAddressLocalhostOrAllInterfaces } from '../../../services/remote/common/remoteExplorerService.js';
+import { TUNNEL_VIEW_ID, TunnelType, makeAddress, IRemoteExplorerService, TunnelEditId, parseAddress, TunnelCloseReason, mapHasAddressLocalhostOrAllInterfaces } from '../../../services/remote/common/remoteExplorerService.js';
 import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
 import { INotificationService, Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
@@ -1099,7 +1099,7 @@ var ClosePortAction;
                 return;
             }
             return Promise.all(( (ports.map(
-                port => remoteExplorerService.close({ host: port.remoteHost, port: port.remotePort })
+                port => remoteExplorerService.close({ host: port.remoteHost, port: port.remotePort }, TunnelCloseReason.User)
             ))));
         };
     }
@@ -1113,7 +1113,7 @@ var ClosePortAction;
             const picks = makeTunnelPicks(Array.from(( (remoteExplorerService.tunnelModel.forwarded.values()))).filter(tunnel => tunnel.closeable), remoteExplorerService, tunnelService);
             const result = await quickInputService.pick(picks, { placeHolder: ( (nls.localize('remote.tunnel.closePlaceholder', "Choose a port to stop forwarding"))) });
             if (result && result.tunnel) {
-                await remoteExplorerService.close({ host: result.tunnel.remoteHost, port: result.tunnel.remotePort });
+                await remoteExplorerService.close({ host: result.tunnel.remoteHost, port: result.tunnel.remotePort }, TunnelCloseReason.User);
             }
             else if (result) {
                 await commandService.executeCommand(ForwardPortAction.COMMANDPALETTE_ID);
@@ -1322,7 +1322,7 @@ var ChangeLocalPortAction;
                     onFinish: async (value, success) => {
                         remoteExplorerService.setEditable(tunnelItem, TunnelEditId.LocalPort, null);
                         if (success) {
-                            await remoteExplorerService.close({ host: tunnelItem.remoteHost, port: tunnelItem.remotePort });
+                            await remoteExplorerService.close({ host: tunnelItem.remoteHost, port: tunnelItem.remotePort }, TunnelCloseReason.Other);
                             const numberValue = Number(value);
                             const newForward = await remoteExplorerService.forward({
                                 remote: { host: tunnelItem.remoteHost, port: tunnelItem.remotePort },
@@ -1355,7 +1355,7 @@ var ChangeTunnelPrivacyAction;
         return async (accessor, arg) => {
             if (isITunnelItem(arg)) {
                 const remoteExplorerService = accessor.get(IRemoteExplorerService);
-                await remoteExplorerService.close({ host: arg.remoteHost, port: arg.remotePort });
+                await remoteExplorerService.close({ host: arg.remoteHost, port: arg.remotePort }, TunnelCloseReason.Other);
                 return remoteExplorerService.forward({
                     remote: { host: arg.remoteHost, port: arg.remotePort },
                     local: arg.localPort,

package/dist/vscode/vs/workbench/contrib/search/browser/media/searchview.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".search-view{display:flex;flex-direction:column;height:100%}.search-view .results{flex-grow:1;min-height:0}.search-view .search-widgets-container{margin:0 12px 0 2px;padding-bottom:6px;padding-top:6px}.search-view .search-widget .toggle-replace-button{align-items:center;background-position:50%;background-repeat:no-repeat;box-sizing:border-box;color:inherit;cursor:pointer;display:flex;height:100%;justify-content:center;left:0;position:absolute;top:0;width:16px}.monaco-workbench .search-view .search-widget .toggle-replace-button:hover{background-color:var(--vscode-toolbar-hoverBackground)}.monaco-workbench .search-view .search-widget .toggle-replace-button:active{background-color:var(--vscode-toolbar-activeBackground)}.search-view .search-widget .replace-container,.search-view .search-widget .search-container{margin-left:18px}.search-view .search-widget .monaco-inputbox>.ibwrapper{height:100%}.search-view .search-widget .monaco-inputbox>.ibwrapper>.mirror,.search-view .search-widget .monaco-inputbox>.ibwrapper>textarea.input{padding:3px 0 3px 6px}.search-view .search-widget .monaco-inputbox>.ibwrapper>textarea.input{height:26px;overflow:initial}.search-view .search-widget .monaco-findInput .monaco-scrollable-element .scrollbar{opacity:0}.search-view .monaco-inputbox>.ibwrapper>textarea.input{scrollbar-width:none}.search-view .monaco-inputbox>.ibwrapper>textarea.input::-webkit-scrollbar{display:none}.search-view .monaco-findInput{display:inline-block;vertical-align:middle;width:100%}.search-view .search-widget .replace-container{display:inline-flex;margin-top:6px;position:relative}.search-view .search-widget .replace-input{display:flex;position:relative;vertical-align:middle;width:auto!important}.search-view .search-widget .replace-input>.controls{position:absolute;right:2px;top:3px}.search-view .search-widget .replace-container.disabled{display:none}.search-view .search-widget .replace-container .monaco-action-bar{height:25px;margin-left:4px}.search-view .query-details{margin:0 0 0 18px;min-height:1em;position:relative}.search-view .query-details .more{color:inherit;cursor:pointer;height:16px;position:absolute;right:-2px;width:25px;z-index:2}.search-view .query-details .file-types{display:none}.search-view .query-details .file-types>.monaco-inputbox{height:25px;width:100%}.search-view .query-details.more .file-types{display:inherit}.search-view .query-details.more .file-types:last-child{padding-bottom:4px}.search-view .query-details.more h4{font-size:11px;font-weight:400;margin:0;overflow:hidden;padding:4px 0 0;text-overflow:ellipsis;white-space:nowrap}.search-view .messages{color:var(--vscode-search-resultsInfoForeground);cursor:default;margin-top:-5px}.search-view .message{overflow-wrap:break-word;padding:0 22px 8px}.search-view .message p:first-child{margin-bottom:0;margin-top:0;padding-bottom:4px;user-select:text;-webkit-user-select:text}.search-view .message a{color:var(--vscode-textLink-foreground)}.search-view .message a:active,.search-view .message a:hover{color:var(--vscode-textLink-activeForeground)}.search-view .filematch,.search-view .foldermatch{display:flex;height:100%;line-height:22px;padding:0;position:relative}.pane-body:not(.wide) .search-view .filematch .monaco-icon-label,.pane-body:not(.wide) .search-view .foldermatch .monaco-icon-label,.pane-body:not(.wide) .search-view .monaco-list .monaco-list-row.focused .filematch .monaco-icon-label,.pane-body:not(.wide) .search-view .monaco-list .monaco-list-row.focused .foldermatch .monaco-icon-label,.pane-body:not(.wide) .search-view .monaco-list .monaco-list-row:hover:not(.highlighted) .filematch .monaco-icon-label,.pane-body:not(.wide) .search-view .monaco-list .monaco-list-row:hover:not(.highlighted) .foldermatch .monaco-icon-label{flex:1}.pane-body.wide .search-view .filematch .badge,.pane-body.wide .search-view .foldermatch .badge{margin-left:10px}.search-view .linematch{display:flex;line-height:22px;overflow:hidden;position:relative}.search-view .linematch>.match{overflow:hidden;text-overflow:ellipsis;white-space:pre}.search-view .linematch .matchLineNum{display:none;font-size:.9em;margin-left:7px;margin-right:4px;opacity:.7}.search-view .linematch .matchLineNum.show{display:block}.pane-body.wide .search-view .monaco-list .monaco-list-row .filematch .actionBarContainer,.pane-body.wide .search-view .monaco-list .monaco-list-row .foldermatch .actionBarContainer,.search-view .monaco-list .monaco-list-row .linematch .actionBarContainer{flex:1 0 auto}.pane-body:not(.wide) .search-view .monaco-list .monaco-list-row .filematch .actionBarContainer,.pane-body:not(.wide) .search-view .monaco-list .monaco-list-row .foldermatch .actionBarContainer{flex:0 0 auto}.pane-body:not(.wide) .search-view .monaco-list .monaco-list-row .linematch .actionBarContainer,.search-view.actions-right .monaco-list .monaco-list-row .filematch .actionBarContainer,.search-view.actions-right .monaco-list .monaco-list-row .foldermatch .actionBarContainer,.search-view.actions-right .monaco-list .monaco-list-row .linematch .actionBarContainer{text-align:right}.search-view .monaco-list .monaco-list-row .monaco-action-bar{display:none;line-height:1em;padding:0 .8em 0 .4em}.search-view .monaco-list .monaco-list-row .monaco-action-bar .action-item{margin:0}.search-view .monaco-list .monaco-list-row.focused .monaco-action-bar,.search-view .monaco-list .monaco-list-row.selected .monaco-action-bar,.search-view .monaco-list .monaco-list-row:hover:not(.highlighted) .monaco-action-bar{display:inline-block}.search-view .monaco-list .monaco-list-row .monaco-action-bar .action-item{margin-right:.2em}.search-view .monaco-list .monaco-list-row .monaco-action-bar .action-label{padding:2px}.monaco-workbench.hc-black .search-view .monaco-list .monaco-list-row .monaco-action-bar .action-label,.monaco-workbench.hc-light .search-view .monaco-list .monaco-list-row .monaco-action-bar .action-label{margin-top:2px}.search-view .monaco-count-badge{margin-right:12px}.pane-body:not(.wide) .search-view>.results>.monaco-list .monaco-list-row.focused .filematch .monaco-count-badge,.pane-body:not(.wide) .search-view>.results>.monaco-list .monaco-list-row.focused .foldermatch .monaco-count-badge,.pane-body:not(.wide) .search-view>.results>.monaco-list .monaco-list-row.focused .linematch .monaco-count-badge,.pane-body:not(.wide) .search-view>.results>.monaco-list .monaco-list-row:hover .filematch .monaco-count-badge,.pane-body:not(.wide) .search-view>.results>.monaco-list .monaco-list-row:hover .foldermatch .monaco-count-badge,.pane-body:not(.wide) .search-view>.results>.monaco-list .monaco-list-row:hover .linematch .monaco-count-badge{display:none}.search-view .replace.findInFileMatch{background-color:var(--vscode-diffEditor-removedTextBackground);border:1px solid var(--vscode-diffEditor-removedTextBackground);text-decoration:line-through}.monaco-workbench.hc-dark .search-view .replace.findInFileMatch,.monaco-workbench.hc-light .search-view .replace.findInFileMatch{border:1px dashed var(--vscode-diffEditor-removedTextBackground)}.search-view .findInFileMatch,.search-view .replaceMatch{white-space:pre}.search-view .findInFileMatch{background-color:var(--vscode-editor-findMatchHighlightBackground);border:1px solid var(--vscode-editor-findMatchHighlightBorder)}.monaco-workbench.hc-dark .search-view .findInFileMatch,.monaco-workbench.hc-light .search-view .findInFileMatch{border:1px dashed var(--vscode-editor-findMatchHighlightBorder)}.search-view .replaceMatch{background-color:var(--vscode-diffEditor-insertedTextBackground)}.monaco-workbench.hc-black .search-view .findInFileMatch,.monaco-workbench.hc-black .search-view .replaceMatch,.monaco-workbench.hc-light .search-view .findInFileMatch,.monaco-workbench.hc-light .search-view .replaceMatch{background:none!important;box-sizing:border-box}.search-view .replaceMatch:not(:empty){border:1px solid var(--vscode-diffEditor-insertedLineBackground)}.monaco-workbench.hc-dark .search-view .replaceMatch:not(:empty),.monaco-workbench.hc-light .search-view .replaceMatch:not(:empty){border:1px dashed var(--vscode-diffEditor-insertedLineBackground)}.monaco-workbench.hc-black .search-view .filematch,.monaco-workbench.hc-black .search-view .foldermatch,.monaco-workbench.hc-black .search-view .linematch,.monaco-workbench.hc-light .search-view .filematch,.monaco-workbench.hc-light .search-view .foldermatch,.monaco-workbench.hc-light .search-view .linematch{line-height:20px}.monaco-workbench.vs .search-panel .search-view .monaco-inputbox{border:1px solid transparent}.text-search-provider-messages .providerMessage{padding-top:4px}.text-search-provider-messages .providerMessage .codicon{padding-right:3px;position:relative;top:3px}.monaco-workbench .search-view .monaco-list.element-focused .monaco-list-row.focused.selected:not(.highlighted) .action-label:focus{outline-color:var(--vscode-list-activeSelectionForeground)}.monaco-workbench .search-container .monaco-custom-toggle.disabled{background-color:inherit!important;cursor:default;opacity:.3;pointer-events:none;user-select:none;-webkit-user-select:none}.monaco-workbench .search-container .find-filter-button{box-sizing:border-box;color:inherit;cursor:pointer;float:left;margin-left:2px;user-select:none;-webkit-user-select:none}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/contrib/search/browser/patternInputWidget.js

@@ -0,0 +1,217 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Toggle } from 'monaco-editor/esm/vs/base/browser/ui/toggle/toggle.js';
+import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ContextScopedHistoryInputBox } from 'monaco-editor/esm/vs/platform/history/browser/contextScopedHistoryWidget.js';
+import { showHistoryKeybindingHint } from 'monaco-editor/esm/vs/platform/history/browser/historyWidgetKeybindingHint.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { defaultToggleStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+let PatternInputWidget = class PatternInputWidget extends Widget {
+    constructor(parent, contextViewProvider, options, contextKeyService, configurationService, keybindingService) {
+        super();
+        this.contextViewProvider = contextViewProvider;
+        this.contextKeyService = contextKeyService;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this._onSubmit = this._register(( new Emitter()));
+        this.onSubmit = this._onSubmit.event;
+        this._onCancel = this._register(( new Emitter()));
+        this.onCancel = this._onCancel.event;
+        options = {
+            ...{
+                ariaLabel: ( nls.localize('defaultLabel', "input"))
+            },
+            ...options,
+        };
+        this.width = options.width ?? 100;
+        this.render(options);
+        parent.appendChild(this.domNode);
+    }
+    dispose() {
+        super.dispose();
+        this.inputFocusTracker?.dispose();
+    }
+    setWidth(newWidth) {
+        this.width = newWidth;
+        this.contextViewProvider.layout();
+        this.setInputWidth();
+    }
+    getValue() {
+        return this.inputBox.value;
+    }
+    setValue(value) {
+        if (this.inputBox.value !== value) {
+            this.inputBox.value = value;
+        }
+    }
+    select() {
+        this.inputBox.select();
+    }
+    focus() {
+        this.inputBox.focus();
+    }
+    inputHasFocus() {
+        return this.inputBox.hasFocus();
+    }
+    setInputWidth() {
+        this.inputBox.width = this.width - this.getSubcontrolsWidth() - 2;
+    }
+    getSubcontrolsWidth() {
+        return 0;
+    }
+    getHistory() {
+        return this.inputBox.getHistory();
+    }
+    clearHistory() {
+        this.inputBox.clearHistory();
+    }
+    clear() {
+        this.setValue('');
+    }
+    onSearchSubmit() {
+        this.inputBox.addToHistory();
+    }
+    showNextTerm() {
+        this.inputBox.showNextValue();
+    }
+    showPreviousTerm() {
+        this.inputBox.showPreviousValue();
+    }
+    render(options) {
+        this.domNode = document.createElement('div');
+        this.domNode.classList.add('monaco-findInput');
+        this.inputBox = ( new ContextScopedHistoryInputBox(this.domNode, this.contextViewProvider, {
+            placeholder: options.placeholder,
+            showPlaceholderOnFocus: options.showPlaceholderOnFocus,
+            tooltip: options.tooltip,
+            ariaLabel: options.ariaLabel,
+            validationOptions: {
+                validation: undefined
+            },
+            history: options.history || [],
+            showHistoryHint: () => showHistoryKeybindingHint(this.keybindingService),
+            inputBoxStyles: options.inputBoxStyles
+        }, this.contextKeyService));
+        this._register(this.inputBox.onDidChange(() => this._onSubmit.fire(true)));
+        this.inputFocusTracker = dom.trackFocus(this.inputBox.inputElement);
+        this.onkeyup(this.inputBox.inputElement, (keyboardEvent) => this.onInputKeyUp(keyboardEvent));
+        const controls = document.createElement('div');
+        controls.className = 'controls';
+        this.renderSubcontrols(controls);
+        this.domNode.appendChild(controls);
+        this.setInputWidth();
+    }
+    renderSubcontrols(_controlsDiv) {
+    }
+    onInputKeyUp(keyboardEvent) {
+        switch (keyboardEvent.keyCode) {
+            case 3 :
+                this.onSearchSubmit();
+                this._onSubmit.fire(false);
+                return;
+            case 9 :
+                this._onCancel.fire();
+                return;
+        }
+    }
+};
+PatternInputWidget.OPTION_CHANGE = 'optionChange';
+PatternInputWidget = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IKeybindingService))
+], PatternInputWidget));
+let IncludePatternInputWidget = class IncludePatternInputWidget extends PatternInputWidget {
+    constructor(parent, contextViewProvider, options, contextKeyService, configurationService, keybindingService) {
+        super(parent, contextViewProvider, options, contextKeyService, configurationService, keybindingService);
+        this._onChangeSearchInEditorsBoxEmitter = this._register(( new Emitter()));
+        this.onChangeSearchInEditorsBox = this._onChangeSearchInEditorsBoxEmitter.event;
+    }
+    dispose() {
+        super.dispose();
+        this.useSearchInEditorsBox.dispose();
+    }
+    onlySearchInOpenEditors() {
+        return this.useSearchInEditorsBox.checked;
+    }
+    setOnlySearchInOpenEditors(value) {
+        this.useSearchInEditorsBox.checked = value;
+        this._onChangeSearchInEditorsBoxEmitter.fire();
+    }
+    getSubcontrolsWidth() {
+        return super.getSubcontrolsWidth() + this.useSearchInEditorsBox.width();
+    }
+    renderSubcontrols(controlsDiv) {
+        this.useSearchInEditorsBox = this._register(( new Toggle({
+            icon: Codicon.book,
+            title: ( nls.localize('onlySearchInOpenEditors', "Search only in Open Editors")),
+            isChecked: false,
+            ...defaultToggleStyles
+        })));
+        this._register(this.useSearchInEditorsBox.onChange(viaKeyboard => {
+            this._onChangeSearchInEditorsBoxEmitter.fire();
+            if (!viaKeyboard) {
+                this.inputBox.focus();
+            }
+        }));
+        controlsDiv.appendChild(this.useSearchInEditorsBox.domNode);
+        super.renderSubcontrols(controlsDiv);
+    }
+};
+IncludePatternInputWidget = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IKeybindingService))
+], IncludePatternInputWidget));
+let ExcludePatternInputWidget = class ExcludePatternInputWidget extends PatternInputWidget {
+    constructor(parent, contextViewProvider, options, contextKeyService, configurationService, keybindingService) {
+        super(parent, contextViewProvider, options, contextKeyService, configurationService, keybindingService);
+        this._onChangeIgnoreBoxEmitter = this._register(( new Emitter()));
+        this.onChangeIgnoreBox = this._onChangeIgnoreBoxEmitter.event;
+    }
+    dispose() {
+        super.dispose();
+        this.useExcludesAndIgnoreFilesBox.dispose();
+    }
+    useExcludesAndIgnoreFiles() {
+        return this.useExcludesAndIgnoreFilesBox.checked;
+    }
+    setUseExcludesAndIgnoreFiles(value) {
+        this.useExcludesAndIgnoreFilesBox.checked = value;
+        this._onChangeIgnoreBoxEmitter.fire();
+    }
+    getSubcontrolsWidth() {
+        return super.getSubcontrolsWidth() + this.useExcludesAndIgnoreFilesBox.width();
+    }
+    renderSubcontrols(controlsDiv) {
+        this.useExcludesAndIgnoreFilesBox = this._register(( new Toggle({
+            icon: Codicon.exclude,
+            actionClassName: 'useExcludesAndIgnoreFiles',
+            title: ( nls.localize(
+                'useExcludesAndIgnoreFilesDescription',
+                "Use Exclude Settings and Ignore Files"
+            )),
+            isChecked: true,
+            ...defaultToggleStyles
+        })));
+        this._register(this.useExcludesAndIgnoreFilesBox.onChange(viaKeyboard => {
+            this._onChangeIgnoreBoxEmitter.fire();
+            if (!viaKeyboard) {
+                this.inputBox.focus();
+            }
+        }));
+        controlsDiv.appendChild(this.useExcludesAndIgnoreFilesBox.domNode);
+        super.renderSubcontrols(controlsDiv);
+    }
+};
+ExcludePatternInputWidget = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IKeybindingService))
+], ExcludePatternInputWidget));
+export { ExcludePatternInputWidget, IncludePatternInputWidget, PatternInputWidget };

package/dist/vscode/vs/workbench/contrib/search/browser/replace.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IReplaceService = ( createDecorator('replaceService'));
+export { IReplaceService };

package/dist/vscode/vs/workbench/contrib/search/browser/replaceContributions.js

@@ -0,0 +1,7 @@
+import { ReplacePreviewContentProvider } from './replaceService.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+function registerContributions() {
+    ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ReplacePreviewContentProvider, 1 );
+}
+export { registerContributions };

package/dist/vscode/vs/workbench/contrib/search/browser/replaceService.js

@@ -0,0 +1,222 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as network from 'monaco-editor/esm/vs/base/common/network.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IReplaceService } from './replace.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ISearchWorkbenchService, Match, MatchInNotebook, FileMatch } from './searchModel.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { createTextBufferFactoryFromSnapshot } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+import { ResourceTextEdit, IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { SaveSourceRegistry } from '../../../common/editor.js';
+import { CellUri } from '../../notebook/common/notebookCommon.js';
+import { INotebookEditorModelResolverService } from '../../notebook/common/notebookEditorModelResolverService.js';
+const REPLACE_PREVIEW = 'replacePreview';
+const toReplaceResource = (fileResource) => {
+    return fileResource.with({ scheme: network.Schemas.internal, fragment: REPLACE_PREVIEW, query: JSON.stringify({ scheme: fileResource.scheme }) });
+};
+const toFileResource = (replaceResource) => {
+    return replaceResource.with({ scheme: JSON.parse(replaceResource.query)['scheme'], fragment: '', query: '' });
+};
+let ReplacePreviewContentProvider = class ReplacePreviewContentProvider {
+    constructor(instantiationService, textModelResolverService) {
+        this.instantiationService = instantiationService;
+        this.textModelResolverService = textModelResolverService;
+        this.textModelResolverService.registerTextModelContentProvider(network.Schemas.internal, this);
+    }
+    provideTextContent(uri) {
+        if (uri.fragment === REPLACE_PREVIEW) {
+            return this.instantiationService.createInstance(ReplacePreviewModel).resolve(uri);
+        }
+        return null;
+    }
+};
+ReplacePreviewContentProvider = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ITextModelService))
+], ReplacePreviewContentProvider));
+let ReplacePreviewModel = class ReplacePreviewModel extends Disposable {
+    constructor(modelService, languageService, textModelResolverService, replaceService, searchWorkbenchService) {
+        super();
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.textModelResolverService = textModelResolverService;
+        this.replaceService = replaceService;
+        this.searchWorkbenchService = searchWorkbenchService;
+    }
+    async resolve(replacePreviewUri) {
+        const fileResource = toFileResource(replacePreviewUri);
+        const fileMatch = this.searchWorkbenchService.searchModel.searchResult.matches().filter(match => ( match.resource.toString()) === ( fileResource.toString()))[0];
+        const ref = this._register(await this.textModelResolverService.createModelReference(fileResource));
+        const sourceModel = ref.object.textEditorModel;
+        const sourceModelLanguageId = sourceModel.getLanguageId();
+        const replacePreviewModel = this.modelService.createModel(createTextBufferFactoryFromSnapshot(sourceModel.createSnapshot()), this.languageService.createById(sourceModelLanguageId), replacePreviewUri);
+        this._register(fileMatch.onChange(({ forceUpdateModel }) => this.update(sourceModel, replacePreviewModel, fileMatch, forceUpdateModel)));
+        this._register(this.searchWorkbenchService.searchModel.onReplaceTermChanged(() => this.update(sourceModel, replacePreviewModel, fileMatch)));
+        this._register(fileMatch.onDispose(() => replacePreviewModel.dispose()));
+        this._register(replacePreviewModel.onWillDispose(() => this.dispose()));
+        this._register(sourceModel.onWillDispose(() => this.dispose()));
+        return replacePreviewModel;
+    }
+    update(sourceModel, replacePreviewModel, fileMatch, override = false) {
+        if (!sourceModel.isDisposed() && !replacePreviewModel.isDisposed()) {
+            this.replaceService.updateReplacePreview(fileMatch, override);
+        }
+    }
+};
+ReplacePreviewModel = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ILanguageService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IReplaceService)),
+    ( __param(4, ISearchWorkbenchService))
+], ReplacePreviewModel));
+let ReplaceService = class ReplaceService {
+    constructor(textFileService, editorService, textModelResolverService, bulkEditorService, labelService, notebookEditorModelResolverService) {
+        this.textFileService = textFileService;
+        this.editorService = editorService;
+        this.textModelResolverService = textModelResolverService;
+        this.bulkEditorService = bulkEditorService;
+        this.labelService = labelService;
+        this.notebookEditorModelResolverService = notebookEditorModelResolverService;
+    }
+    async replace(arg, progress = undefined, resource = null) {
+        const edits = this.createEdits(arg, resource);
+        await this.bulkEditorService.apply(edits, { progress });
+        const rawTextPromises = ( edits.map(async (e) => {
+            if (e.resource.scheme === network.Schemas.vscodeNotebookCell) {
+                const notebookResource = CellUri.parse(e.resource)?.notebook;
+                if (notebookResource) {
+                    let ref;
+                    try {
+                        ref = await this.notebookEditorModelResolverService.resolve(notebookResource);
+                        await ref.object.save({ source: ReplaceService.REPLACE_SAVE_SOURCE });
+                    }
+                    finally {
+                        ref?.dispose();
+                    }
+                }
+                return;
+            }
+            else {
+                return this.textFileService.files.get(e.resource)?.save({ source: ReplaceService.REPLACE_SAVE_SOURCE });
+            }
+        }));
+        return Promises.settled(rawTextPromises);
+    }
+    async openReplacePreview(element, preserveFocus, sideBySide, pinned) {
+        const fileMatch = element instanceof Match ? element.parent() : element;
+        const editor = await this.editorService.openEditor({
+            original: { resource: fileMatch.resource },
+            modified: { resource: toReplaceResource(fileMatch.resource) },
+            label: ( nls.localize(
+                'fileReplaceChanges',
+                "{0} ↔ {1} (Replace Preview)",
+                fileMatch.name(),
+                fileMatch.name()
+            )),
+            description: this.labelService.getUriLabel(dirname(fileMatch.resource), { relative: true }),
+            options: {
+                preserveFocus,
+                pinned,
+                revealIfVisible: true
+            }
+        });
+        const input = editor?.input;
+        const disposable = fileMatch.onDispose(() => {
+            input?.dispose();
+            disposable.dispose();
+        });
+        await this.updateReplacePreview(fileMatch);
+        if (editor) {
+            const editorControl = editor.getControl();
+            if (element instanceof Match && editorControl) {
+                editorControl.revealLineInCenter(element.range().startLineNumber, 1 );
+            }
+        }
+    }
+    async updateReplacePreview(fileMatch, override = false) {
+        const replacePreviewUri = toReplaceResource(fileMatch.resource);
+        const [sourceModelRef, replaceModelRef] = await Promise.all([this.textModelResolverService.createModelReference(fileMatch.resource), this.textModelResolverService.createModelReference(replacePreviewUri)]);
+        const sourceModel = sourceModelRef.object.textEditorModel;
+        const replaceModel = replaceModelRef.object.textEditorModel;
+        try {
+            if (sourceModel && replaceModel) {
+                if (override) {
+                    replaceModel.setValue(sourceModel.getValue());
+                }
+                else {
+                    replaceModel.undo();
+                }
+                this.applyEditsToPreview(fileMatch, replaceModel);
+            }
+        }
+        finally {
+            sourceModelRef.dispose();
+            replaceModelRef.dispose();
+        }
+    }
+    applyEditsToPreview(fileMatch, replaceModel) {
+        const resourceEdits = this.createEdits(fileMatch, replaceModel.uri);
+        const modelEdits = [];
+        for (const resourceEdit of resourceEdits) {
+            modelEdits.push(EditOperation.replaceMove(Range.lift(resourceEdit.textEdit.range), resourceEdit.textEdit.text));
+        }
+        replaceModel.pushEditOperations([], modelEdits.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range)), () => []);
+    }
+    createEdits(arg, resource = null) {
+        const edits = [];
+        if (arg instanceof Match) {
+            if (arg instanceof MatchInNotebook) {
+                if (!arg.isWebviewMatch()) {
+                    const match = arg;
+                    edits.push(this.createEdit(match, match.replaceString, match.cell.uri));
+                }
+            }
+            else {
+                const match = arg;
+                edits.push(this.createEdit(match, match.replaceString, resource));
+            }
+        }
+        if (arg instanceof FileMatch) {
+            arg = [arg];
+        }
+        if (arg instanceof Array) {
+            arg.forEach(element => {
+                const fileMatch = element;
+                if (fileMatch.count() > 0) {
+                    edits.push(...fileMatch.matches().flatMap(match => this.createEdits(match, resource)));
+                }
+            });
+        }
+        return edits;
+    }
+    createEdit(match, text, resource = null) {
+        const fileMatch = match.parent();
+        return ( new ResourceTextEdit(
+            resource ?? fileMatch.resource,
+            { range: match.range(), text },
+            undefined,
+            undefined
+        ));
+    }
+};
+ReplaceService.REPLACE_SAVE_SOURCE = SaveSourceRegistry.registerSource('searchReplace.source', ( nls.localize('searchReplace.source', "Search and Replace")));
+ReplaceService = ( __decorate([
+    ( __param(0, ITextFileService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IBulkEditService)),
+    ( __param(4, ILabelService)),
+    ( __param(5, INotebookEditorModelResolverService))
+], ReplaceService));
+export { ReplacePreviewContentProvider, ReplaceService };