@codingame/monaco-vscode-api 1.79.2 → 1.79.3-next.2

package/dist/extensions.d.ts

@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import { a as IExtensionDescription, b as IExtensionManifest } from './extensions.d2.ts';
+import { b as IExtensionDescription, I as IExtensionManifest } from './extensions.d2.ts';
 export { c as IExtensionContributions } from './extensions.d2.ts';
 import { I as IMessage } from './extensionsRegistry.js';
 import { a as IDisposable } from './event.js';

package/dist/extensions.d2.ts

@@ -443,4 +443,4 @@ interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest {
 }
 type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
 
-export { ExtensionIdentifier as E, ILocalizedString as I, TargetPlatform as T, IExtensionDescription as a, IExtensionManifest as b, IExtensionContributions as c, ExtensionKind as d, ICommandAction as e, ICommandActionTitle as f, Icon as g, IEnvironmentService as h };
+export { ExtensionIdentifier as E, IExtensionManifest as I, TargetPlatform as T, ILocalizedString as a, IExtensionDescription as b, IExtensionContributions as c, ExtensionKind as d, ICommandAction as e, ICommandActionTitle as f, Icon as g, IEnvironmentService as h };

package/dist/extensionsRegistry.d.ts

@@ -1,5 +1,5 @@
 import { S as ServiceIdentifier } from './instantiation.js';
-import { E as ExtensionIdentifier, a as IExtensionDescription, c as IExtensionContributions, d as ExtensionKind } from './extensions.d2.ts';
+import { E as ExtensionIdentifier, b as IExtensionDescription, c as IExtensionContributions, d as ExtensionKind } from './extensions.d2.ts';
 import { E as Event } from './event.js';
 import { S as Severity } from './severity.js';
 

package/dist/json.js

@@ -4,6 +4,7 @@ import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
 import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
 import { Disposable, extensions } from './api.js';
 const registry = ( Registry.as(Extensions.JSONContribution));
 function getDefaultSchemaAssociations() {
@@ -32,7 +33,7 @@ function getExtensionSchemaAssociations() {
                     if (Array.isArray(fileMatch) && typeof url === 'string') {
                         let uri = url;
                         if (uri[0] === '.' && uri[1] === '/') {
-                            uri = ( monaco.Uri.joinPath(extension.extensionUri, uri).toString());
+                            uri = ( FileAccess.uriToBrowserUri(monaco.Uri.joinPath(extension.extensionUri, uri)).toString());
                         }
                         fileMatch = ( fileMatch.map(fm => {
                             if (fm[0] === '%') {
@@ -78,6 +79,7 @@ function synchronizeJsonSchemas() {
     function updateDiagnosticsOptions() {
         monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
             ...monaco.languages.json.jsonDefaults.diagnosticsOptions,
+            enableSchemaRequest: true,
             schemas: [
                 ...getJsonSchemas(),
                 ...getDefaultSchemaAssociations(),

package/dist/rollup-extension-directory-plugin.d.ts

@@ -1,13 +1,21 @@
 import { FilterPattern } from '@rollup/pluginutils';
 import { Plugin, InputPluginOption } from 'rollup';
+import { I as IExtensionManifest } from './extensions.d2.ts';
+import './uri.js';
+import './contextkey.js';
+import './instantiation.js';
+import './event.js';
+import 'vscode';
+import './themables.js';
 
 interface Options {
     include?: FilterPattern;
     exclude?: FilterPattern;
     isDefaultExtension?: boolean;
     withCode?: (extensionPath: string) => boolean;
-    rollupPlugins: InputPluginOption[];
+    rollupPlugins?: InputPluginOption[];
+    transformManifest?: (manifest: IExtensionManifest) => IExtensionManifest;
 }
-declare function plugin({ include, exclude, isDefaultExtension, withCode, rollupPlugins }: Options): Plugin;
+declare function plugin({ include, exclude, isDefaultExtension, withCode, rollupPlugins, transformManifest }: Options): Plugin;
 
 export { plugin as default };

package/dist/rollup-extension-directory-plugin.js

@@ -1,5 +1,5 @@
 import { createFilter, dataToEsm } from '@rollup/pluginutils';
-import { p as parseJson, l as localizeManifest, b as buildExtensionCode, i as isBinaryFileSync_1, c as compressResource, e as extractResourcesFromExtensionManifest, m as mimeTypes } from './extension-tools-3c2bf0a4.js';
+import { p as parseJson, l as localizeManifest, b as buildExtensionCode, i as isBinaryFileSync_1, c as compressResource, e as extractResourcesFromExtensionManifest, m as mimeTypes } from './extension-tools-13cf24a4.js';
 import * as path from 'path';
 import * as fsPromise from 'fs/promises';
 import * as require$$0$1 from 'fs';
@@ -11,7 +11,7 @@ import 'node:crypto';
 import 'node:fs/promises';
 import 'tty';
 
-function plugin({ include, exclude, isDefaultExtension = false, withCode = () => true, rollupPlugins }) {
+function plugin({ include, exclude, isDefaultExtension = false, withCode = () => true, rollupPlugins = [], transformManifest = manifest => manifest }) {
     const filter = createFilter(include, exclude);
     return {
         name: 'default-extensions-loader',
@@ -36,7 +36,7 @@ function plugin({ include, exclude, isDefaultExtension = false, withCode = () =>
                     parsed = localizeManifest(parsed, parseJson(id, (await fsPromise.readFile(nlsFile)).toString()));
                 }
                 return {
-                    code: dataToEsm(parsed, {
+                    code: dataToEsm(transformManifest(parsed), {
                         compact: true,
                         namedExports: false,
                         preferConst: false
@@ -72,7 +72,7 @@ function plugin({ include, exclude, isDefaultExtension = false, withCode = () =>
             if (stat.isDirectory()) {
                 // Load the extension directory as a module importing the required files and registering the extension
                 const manifestPath = path.resolve(id, 'package.json');
-                const manifest = JSON.parse((await fsPromise.readFile(manifestPath)).toString('utf8'));
+                const manifest = transformManifest(parseJson(id, (await fsPromise.readFile(manifestPath)).toString('utf8')));
                 try {
                     const extensionResources = await extractResourcesFromExtensionManifest(manifest, async (resourcePath) => {
                         return (await fsPromise.readFile(path.join(id, resourcePath)));

package/dist/rollup-vsix-plugin.d.ts

@@ -1,12 +1,20 @@
 import { FilterPattern } from '@rollup/pluginutils';
 import { Plugin, InputPluginOption } from 'rollup';
+import { I as IExtensionManifest } from './extensions.d2.ts';
+import './uri.js';
+import './contextkey.js';
+import './instantiation.js';
+import './event.js';
+import 'vscode';
+import './themables.js';
 
 interface Options {
     include?: FilterPattern;
     exclude?: FilterPattern;
     withCode?: (extensionPath: string) => boolean;
-    rollupPlugins: InputPluginOption[];
+    rollupPlugins?: InputPluginOption[];
+    transformManifest?: (manifest: IExtensionManifest) => IExtensionManifest;
 }
-declare function plugin({ include, exclude, rollupPlugins, withCode }: Options): Plugin;
+declare function plugin({ include, exclude, rollupPlugins, withCode, transformManifest }: Options): Plugin;
 
 export { plugin as default };

package/dist/rollup-vsix-plugin.js

@@ -1,6 +1,6 @@
 import { createFilter, dataToEsm } from '@rollup/pluginutils';
 import * as yauzl from 'yauzl';
-import { b as buildExtensionCode, i as isBinaryFileSync_1, c as compressResource, p as parseJson, l as localizeManifest, e as extractResourcesFromExtensionManifest, m as mimeTypes } from './extension-tools-3c2bf0a4.js';
+import { b as buildExtensionCode, i as isBinaryFileSync_1, c as compressResource, p as parseJson, l as localizeManifest, e as extractResourcesFromExtensionManifest, m as mimeTypes } from './extension-tools-13cf24a4.js';
 import * as path from 'path';
 import 'fs';
 import 'util';
@@ -53,7 +53,7 @@ async function readVsix(file) {
 function getVsixPath(file) {
     return path.relative('/', path.resolve('/', file));
 }
-function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () => true }) {
+function plugin({ include = '**/*.vsix', exclude, rollupPlugins = [], withCode = () => true, transformManifest = manifest => manifest }) {
     const filter = createFilter(include, exclude);
     const vsixFiles = {};
     return {
@@ -81,7 +81,7 @@ function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () =
                         map: { mappings: '' }
                     };
                 }
-                const content = vsixFile[resourcePath];
+                const content = vsixFile[getVsixPath(resourcePath)];
                 if (isBinaryFileSync_1(content)) {
                     return {
                         code: `export default Uint8Array.from(window.atob(${JSON.stringify(content.toString('base64'))}), v => v.charCodeAt(0));`,
@@ -100,11 +100,13 @@ function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () =
                 const file = match[2];
                 const vsixFile = vsixFiles[match[1]];
                 let parsed = parseJson(id, vsixFile[file].toString('utf8'));
-                if (file === 'package.json' && 'package.nls.json' in vsixFile) {
-                    parsed = localizeManifest(parsed, parseJson(id, vsixFile['package.nls.json'].toString()));
+                if (file === 'package.json') {
+                    if ('package.nls.json' in vsixFile) {
+                        parsed = localizeManifest(parsed, parseJson(id, vsixFile['package.nls.json'].toString()));
+                    }
                 }
                 return {
-                    code: dataToEsm(parsed, {
+                    code: dataToEsm(transformManifest(parsed), {
                         compact: true,
                         namedExports: false,
                         preferConst: false
@@ -114,7 +116,7 @@ function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () =
             if (!filter(id))
                 return null;
             const files = await readVsix(id);
-            const manifest = parseJson(id, files['package.json'].toString('utf8'));
+            const manifest = transformManifest(parseJson(id, files['package.json'].toString('utf8')));
             const extensionResources = (await extractResourcesFromExtensionManifest(manifest, async (path) => {
                 return files[getVsixPath(path)];
             })).filter(resource => getVsixPath(resource.path) in files);

package/dist/service-override/dialogs.js

@@ -9,13 +9,41 @@ import { unsupported } from '../tools.js';
 class FileDialogService extends AbstractFileDialogService {
     constructor() {
         super(...arguments);
-        this.pickFileFolderAndOpen = unsupported;
-        this.pickFileAndOpen = unsupported;
-        this.pickFolderAndOpen = unsupported;
         this.pickWorkspaceAndOpen = unsupported;
-        this.showSaveDialog = unsupported;
-        this.showOpenDialog = unsupported;
-        this.pickFileToSave = unsupported;
+    }
+    async pickFileFolderAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (options.defaultUri == null) {
+            options.defaultUri = await this.defaultFilePath(schema);
+        }
+        return super.pickFileFolderAndOpenSimplified(schema, options, false);
+    }
+    async pickFolderAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (options.defaultUri == null) {
+            options.defaultUri = await this.defaultFolderPath(schema);
+        }
+        return super.pickFolderAndOpenSimplified(schema, options);
+    }
+    async pickFileAndOpen(options) {
+        const schema = this.getFileSystemSchema(options);
+        if (options.defaultUri == null) {
+            options.defaultUri = await this.defaultFilePath(schema);
+        }
+        return super.pickFileAndOpenSimplified(schema, options, false);
+    }
+    async showSaveDialog(options) {
+        const schema = this.getFileSystemSchema(options);
+        return super.showSaveDialogSimplified(schema, options);
+    }
+    async showOpenDialog(options) {
+        const schema = this.getFileSystemSchema(options);
+        return super.showOpenDialogSimplified(schema, options);
+    }
+    async pickFileToSave(defaultUri, availableFileSystems) {
+        const schema = this.getFileSystemSchema({ defaultUri, availableFileSystems });
+        const options = this.getPickFileToSaveDialogOptions(defaultUri, availableFileSystems);
+        return super.pickFileToSaveSimplified(schema, options);
     }
 }
 function getServiceOverride(container) {

package/dist/services.d.ts

@@ -19,7 +19,7 @@ import { I as IconIdentifier, T as ThemeIcon } from './themables.js';
 import { I as IJSONSchema, a as IJSONSchemaMap } from './jsonSchema.js';
 import { I as IView$3, a as IViewDescriptorService, b as IViewPaneContainer, c as ViewContainer, d as IViewContainerModel, e as IViewDescriptor, f as IAddedViewDescriptorRef, g as IPaneComposite, V as ViewContainerLocation } from './views.js';
 export { h as IViewsService } from './views.js';
-import { e as ICommandAction, f as ICommandActionTitle, g as Icon, h as IEnvironmentService, E as ExtensionIdentifier, T as TargetPlatform, a as IExtensionDescription } from './extensions.d2.ts';
+import { e as ICommandAction, f as ICommandActionTitle, g as Icon, h as IEnvironmentService, E as ExtensionIdentifier, T as TargetPlatform, b as IExtensionDescription } from './extensions.d2.ts';
 import { b as IProgress, c as IProgressStep, I as IComposite, d as ICompositeControl, a as IProgressIndicator } from './composite.js';
 import { a as IContextKeyService, C as ContextKeyExpression } from './contextkey.js';
 import { a as IExtensionService } from './extensionsRegistry.js';

package/dist/views.d.ts

@@ -3,7 +3,7 @@ import { U as URI } from './uri.js';
 import { E as Event } from './event.js';
 import { T as ThemeIcon } from './themables.js';
 import { C as ContextKeyExpression } from './contextkey.js';
-import { I as ILocalizedString, E as ExtensionIdentifier } from './extensions.d2.ts';
+import { a as ILocalizedString, E as ExtensionIdentifier } from './extensions.d2.ts';
 import { I as IComposite, a as IProgressIndicator } from './composite.js';
 
 interface IKeybindings {

package/dist/vscode/vs/workbench/browser/parts/compositeBar.js

@@ -330,7 +330,11 @@ let CompositeBar = class CompositeBar extends Widget {
         else {
             const compositeSwitcherBar = this.compositeSwitcherBar;
             if (compositeSwitcherBar && this.dimension && this.dimension.height !== 0 && this.dimension.width !== 0) {
+                const currentItemsLength = compositeSwitcherBar.viewItems.length;
                 compositeSwitcherBar.push(( items.map(composite => composite.activityAction)));
+                items.forEach((composite, index) => this.compositeSizeInBar.set(composite.id, this.options.orientation === 1
+                    ? compositeSwitcherBar.getHeight(currentItemsLength + index)
+                    : compositeSwitcherBar.getWidth(currentItemsLength + index)));
                 items.forEach(() => compositeSwitcherBar.pull(compositeSwitcherBar.viewItems.length - 1));
             }
         }

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

@@ -21,6 +21,12 @@ import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/
 import { assertType } from 'monaco-editor/esm/vs/base/common/types.js';
 import { getWorkspaceSymbols } from '../common/search.js';
 import { ShowAllSymbolsActionId } from '../common/constants.js';
+import './searchActionsCopy.js';
+import './searchActionsFind.js';
+import './searchActionsNav.js';
+import './searchActionsRemoveReplace.js';
+import './searchActionsSymbol.js';
+import './searchActionsTopBar.js';
 registerContributions();
 registerContributions$1();
 const SEARCH_MODE_CONFIG = 'search.mode';

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

@@ -1,5 +1,8 @@
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { searchComparer, FileMatch, Match, FolderMatch } from './searchModel.js';
 import { VIEW_ID } from '../../../services/search/common/search.js';
+const category = { value: ( nls.localize('search', "Search")), original: 'Search' };
 function isSearchViewFocused(viewsService) {
     const searchView = getSearchView(viewsService);
     const activeElement = document.activeElement;
@@ -11,7 +14,33 @@ function appendKeyBindingLabel(label, inputKeyBinding) {
 function getSearchView(viewsService) {
     return viewsService.getActiveViewWithId(VIEW_ID);
 }
+function getElementsToOperateOn(viewer, currElement, sortConfig) {
+    let elements = viewer.getSelection().filter((x) => x !== null).sort((a, b) => searchComparer(a, b, sortConfig.sortOrder));
+    if (currElement && !(elements.length > 1 && elements.includes(currElement))) {
+        elements = [currElement];
+    }
+    return elements;
+}
+function shouldRefocus(elements, focusElement) {
+    if (!focusElement) {
+        return false;
+    }
+    return !focusElement || elements.includes(focusElement) || hasDownstreamMatch(elements, focusElement);
+}
+function hasDownstreamMatch(elements, focusElement) {
+    for (const elem of elements) {
+        if ((elem instanceof FileMatch && focusElement instanceof Match && elem.matches().includes(focusElement)) ||
+            (elem instanceof FolderMatch && ((focusElement instanceof FileMatch && elem.getDownstreamFileMatch(focusElement.resource)) ||
+                (focusElement instanceof Match && elem.getDownstreamFileMatch(focusElement.parent().resource))))) {
+            return true;
+        }
+    }
+    return false;
+}
+function openSearchView(viewsService, focus) {
+    return viewsService.openView(VIEW_ID, focus).then(view => (view ?? undefined));
+}
 function doAppendKeyBindingLabel(label, keyBinding) {
     return keyBinding ? label + ' (' + keyBinding.getLabel() + ')' : label;
 }
-export { appendKeyBindingLabel, getSearchView, isSearchViewFocused };
+export { appendKeyBindingLabel, category, getElementsToOperateOn, getSearchView, isSearchViewFocused, openSearchView, shouldRefocus };

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

@@ -0,0 +1,204 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IViewsService } from '../../../common/views.js';
+import { CopyMatchCommandId, FileMatchOrMatchFocusKey, CopyPathCommandId, FileMatchOrFolderMatchWithResourceFocusKey, CopyAllCommandId, HasSearchResults } from '../common/constants.js';
+import { FileMatch, FolderMatchWithResource, Match, FolderMatch, searchMatchComparer } from './searchModel.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { category, getSearchView } from './searchActionsBase.js';
+import { isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+registerAction2(class CopyMatchCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: CopyMatchCommandId,
+            title: {
+                value: ( nls.localize('copyMatchLabel', "Copy")),
+                original: 'Copy'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: FileMatchOrMatchFocusKey,
+                primary: 2048  | 33 ,
+            },
+            menu: [{
+                    id: MenuId.SearchContext,
+                    when: FileMatchOrMatchFocusKey,
+                    group: 'search_2',
+                    order: 1
+                }]
+        });
+    }
+    async run(accessor, match) {
+        await copyMatchCommand(accessor, match);
+    }
+});
+registerAction2(class CopyPathCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: CopyPathCommandId,
+            title: {
+                value: ( nls.localize('copyPathLabel', "Copy Path")),
+                original: 'Copy Path'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: FileMatchOrFolderMatchWithResourceFocusKey,
+                primary: 2048  | 512  | 33 ,
+                win: {
+                    primary: 1024  | 512  | 33
+                },
+            },
+            menu: [{
+                    id: MenuId.SearchContext,
+                    when: FileMatchOrFolderMatchWithResourceFocusKey,
+                    group: 'search_2',
+                    order: 2
+                }]
+        });
+    }
+    async run(accessor, fileMatch) {
+        await copyPathCommand(accessor, fileMatch);
+    }
+});
+registerAction2(class CopyAllCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: CopyAllCommandId,
+            title: {
+                value: ( nls.localize('copyAllLabel', "Copy All")),
+                original: 'Copy All'
+            },
+            category,
+            menu: [{
+                    id: MenuId.SearchContext,
+                    when: HasSearchResults,
+                    group: 'search_2',
+                    order: 3
+                }]
+        });
+    }
+    async run(accessor) {
+        await copyAllCommand(accessor);
+    }
+});
+const lineDelimiter = isWindows ? '\r\n' : '\n';
+async function copyPathCommand(accessor, fileMatch) {
+    if (!fileMatch) {
+        const selection = getSelectedRow(accessor);
+        if (!(selection instanceof FileMatch || selection instanceof FolderMatchWithResource)) {
+            return;
+        }
+        fileMatch = selection;
+    }
+    const clipboardService = accessor.get(IClipboardService);
+    const labelService = accessor.get(ILabelService);
+    const text = labelService.getUriLabel(fileMatch.resource, { noPrefix: true });
+    await clipboardService.writeText(text);
+}
+async function copyMatchCommand(accessor, match) {
+    if (!match) {
+        const selection = getSelectedRow(accessor);
+        if (!selection) {
+            return;
+        }
+        match = selection;
+    }
+    const clipboardService = accessor.get(IClipboardService);
+    const labelService = accessor.get(ILabelService);
+    let text;
+    if (match instanceof Match) {
+        text = matchToString(match);
+    }
+    else if (match instanceof FileMatch) {
+        text = fileMatchToString(match, labelService).text;
+    }
+    else if (match instanceof FolderMatch) {
+        text = folderMatchToString(match, labelService).text;
+    }
+    if (text) {
+        await clipboardService.writeText(text);
+    }
+}
+async function copyAllCommand(accessor) {
+    const viewsService = accessor.get(IViewsService);
+    const clipboardService = accessor.get(IClipboardService);
+    const labelService = accessor.get(ILabelService);
+    const searchView = getSearchView(viewsService);
+    if (searchView) {
+        const root = searchView.searchResult;
+        const text = allFolderMatchesToString(root.folderMatches(), labelService);
+        await clipboardService.writeText(text);
+    }
+}
+function matchToString(match, indent = 0) {
+    const getFirstLinePrefix = () => `${match.range().startLineNumber},${match.range().startColumn}`;
+    const getOtherLinePrefix = (i) => match.range().startLineNumber + i + '';
+    const fullMatchLines = match.fullPreviewLines();
+    const largestPrefixSize = fullMatchLines.reduce((largest, _, i) => {
+        const thisSize = i === 0 ?
+            getFirstLinePrefix().length :
+            getOtherLinePrefix(i).length;
+        return Math.max(thisSize, largest);
+    }, 0);
+    const formattedLines = ( fullMatchLines
+        .map((line, i) => {
+        const prefix = i === 0 ?
+            getFirstLinePrefix() :
+            getOtherLinePrefix(i);
+        const paddingStr = ' '.repeat(largestPrefixSize - prefix.length);
+        const indentStr = ' '.repeat(indent);
+        return `${indentStr}${prefix}: ${paddingStr}${line}`;
+    }));
+    return formattedLines.join('\n');
+}
+function fileFolderMatchToString(match, labelService) {
+    if (match instanceof FileMatch) {
+        return fileMatchToString(match, labelService);
+    }
+    else {
+        return folderMatchToString(match, labelService);
+    }
+}
+function fileMatchToString(fileMatch, labelService) {
+    const matchTextRows = ( fileMatch.matches()
+        .sort(searchMatchComparer)
+        .map(match => matchToString(match, 2)));
+    const uriString = labelService.getUriLabel(fileMatch.resource, { noPrefix: true });
+    return {
+        text: `${uriString}${lineDelimiter}${matchTextRows.join(lineDelimiter)}`,
+        count: matchTextRows.length
+    };
+}
+function folderMatchToString(folderMatch, labelService) {
+    const results = [];
+    let numMatches = 0;
+    const matches = folderMatch.matches().sort(searchMatchComparer);
+    matches.forEach(match => {
+        const result = fileFolderMatchToString(match, labelService);
+        numMatches += result.count;
+        results.push(result.text);
+    });
+    return {
+        text: results.join(lineDelimiter + lineDelimiter),
+        count: numMatches
+    };
+}
+function allFolderMatchesToString(folderMatches, labelService) {
+    const folderResults = [];
+    folderMatches = folderMatches.sort(searchMatchComparer);
+    for (let i = 0; i < folderMatches.length; i++) {
+        const folderResult = folderMatchToString(folderMatches[i], labelService);
+        if (folderResult.count) {
+            folderResults.push(folderResult.text);
+        }
+    }
+    return folderResults.join(lineDelimiter + lineDelimiter);
+}
+function getSelectedRow(accessor) {
+    const viewsService = accessor.get(IViewsService);
+    const searchView = getSearchView(viewsService);
+    return searchView?.getControl().getSelection()[0];
+}
+export { lineDelimiter };