@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common 20.0.0

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common",
+  "version": "20.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package (chat, debug, edit-sessions, editor, explorer, extension-gallery, extensions, interactive, mcp, multi-diff-editor, notebook, outline, output, preferences, quickaccess, scm, search, task, terminal, timeline, user-data-profile, user-data-sync, view-common, view-title-bar, views, workbench)",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common": "20.0.0",
+    "@codingame/monaco-vscode-api": "20.0.0"
+  },
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

package/vscode/src/vs/base/common/fuzzyScorer.d.ts

@@ -0,0 +1,41 @@
+import { IMatch } from "@codingame/monaco-vscode-api/vscode/vs/base/common/filters";
+export type FuzzyScore = [
+    number,
+    number[]
+];
+export type FuzzyScorerCache = {
+    [key: string]: IItemScore;
+};
+export declare function scoreFuzzy(target: string, query: string, queryLower: string, allowNonContiguousMatches: boolean): FuzzyScore;
+export type FuzzyScore2 = [
+    number | undefined,
+    IMatch[]
+];
+export declare function scoreFuzzy2(target: string, query: IPreparedQuery | IPreparedQueryPiece, patternStart?: number, wordStart?: number): FuzzyScore2;
+export interface IItemScore {
+    score: number;
+    labelMatch?: IMatch[];
+    descriptionMatch?: IMatch[];
+}
+export interface IItemAccessor<T> {
+    getItemLabel(item: T): string | undefined;
+    getItemDescription(item: T): string | undefined;
+    getItemPath(file: T): string | undefined;
+}
+export declare function scoreItemFuzzy<T>(item: T, query: IPreparedQuery, allowNonContiguousMatches: boolean, accessor: IItemAccessor<T>, cache: FuzzyScorerCache): IItemScore;
+export declare function compareItemsByFuzzyScore<T>(itemA: T, itemB: T, query: IPreparedQuery, allowNonContiguousMatches: boolean, accessor: IItemAccessor<T>, cache: FuzzyScorerCache): number;
+export interface IPreparedQueryPiece {
+    original: string;
+    originalLowercase: string;
+    pathNormalized: string;
+    normalized: string;
+    normalizedLowercase: string;
+    expectContiguousMatch: boolean;
+}
+export interface IPreparedQuery extends IPreparedQueryPiece {
+    values: IPreparedQueryPiece[] | undefined;
+    containsPathSeparator: boolean;
+}
+export declare function prepareQuery(original: string): IPreparedQuery;
+export declare function pieceToQuery(piece: IPreparedQueryPiece): IPreparedQuery;
+export declare function pieceToQuery(pieces: IPreparedQueryPiece[]): IPreparedQuery;

package/vscode/src/vs/base/common/fuzzyScorer.js

@@ -0,0 +1,487 @@
+
+import { CharCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
+import { compareAnything } from '@codingame/monaco-vscode-api/vscode/vs/base/common/comparers';
+import { isUpper, fuzzyScore, createMatches as createMatches$1, matchesPrefix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/filters';
+import { hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { sep } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { isLinux, isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { equalsIgnoreCase, stripWildcards } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+
+const NO_MATCH = 0;
+const NO_SCORE = [NO_MATCH, []];
+function scoreFuzzy(target, query, queryLower, allowNonContiguousMatches) {
+    if (!target || !query) {
+        return NO_SCORE;
+    }
+    const targetLength = target.length;
+    const queryLength = query.length;
+    if (targetLength < queryLength) {
+        return NO_SCORE;
+    }
+    const targetLower = target.toLowerCase();
+    const res = doScoreFuzzy(query, queryLower, queryLength, target, targetLower, targetLength, allowNonContiguousMatches);
+    return res;
+}
+function doScoreFuzzy(query, queryLower, queryLength, target, targetLower, targetLength, allowNonContiguousMatches) {
+    const scores = [];
+    const matches = [];
+    for (let queryIndex = 0; queryIndex < queryLength; queryIndex++) {
+        const queryIndexOffset = queryIndex * targetLength;
+        const queryIndexPreviousOffset = queryIndexOffset - targetLength;
+        const queryIndexGtNull = queryIndex > 0;
+        const queryCharAtIndex = query[queryIndex];
+        const queryLowerCharAtIndex = queryLower[queryIndex];
+        for (let targetIndex = 0; targetIndex < targetLength; targetIndex++) {
+            const targetIndexGtNull = targetIndex > 0;
+            const currentIndex = queryIndexOffset + targetIndex;
+            const leftIndex = currentIndex - 1;
+            const diagIndex = queryIndexPreviousOffset + targetIndex - 1;
+            const leftScore = targetIndexGtNull ? scores[leftIndex] : 0;
+            const diagScore = queryIndexGtNull && targetIndexGtNull ? scores[diagIndex] : 0;
+            const matchesSequenceLength = queryIndexGtNull && targetIndexGtNull ? matches[diagIndex] : 0;
+            let score;
+            if (!diagScore && queryIndexGtNull) {
+                score = 0;
+            }
+            else {
+                score = computeCharScore(queryCharAtIndex, queryLowerCharAtIndex, target, targetLower, targetIndex, matchesSequenceLength);
+            }
+            const isValidScore = score && diagScore + score >= leftScore;
+            if (isValidScore && (
+            (allowNonContiguousMatches ||
+                queryIndexGtNull ||
+            targetLower.startsWith(queryLower, targetIndex)))) {
+                matches[currentIndex] = matchesSequenceLength + 1;
+                scores[currentIndex] = diagScore + score;
+            }
+            else {
+                matches[currentIndex] = NO_MATCH;
+                scores[currentIndex] = leftScore;
+            }
+        }
+    }
+    const positions = [];
+    let queryIndex = queryLength - 1;
+    let targetIndex = targetLength - 1;
+    while (queryIndex >= 0 && targetIndex >= 0) {
+        const currentIndex = queryIndex * targetLength + targetIndex;
+        const match = matches[currentIndex];
+        if (match === NO_MATCH) {
+            targetIndex--;
+        }
+        else {
+            positions.push(targetIndex);
+            queryIndex--;
+            targetIndex--;
+        }
+    }
+    return [scores[queryLength * targetLength - 1], positions.reverse()];
+}
+function computeCharScore(queryCharAtIndex, queryLowerCharAtIndex, target, targetLower, targetIndex, matchesSequenceLength) {
+    let score = 0;
+    if (!considerAsEqual(queryLowerCharAtIndex, targetLower[targetIndex])) {
+        return score;
+    }
+    score += 1;
+    if (matchesSequenceLength > 0) {
+        score += (Math.min(matchesSequenceLength, 3) * 6) + (Math.max(0, matchesSequenceLength - 3) * 3);
+    }
+    if (queryCharAtIndex === target[targetIndex]) {
+        score += 1;
+    }
+    if (targetIndex === 0) {
+        score += 8;
+    }
+    else {
+        const separatorBonus = scoreSeparatorAtPos(target.charCodeAt(targetIndex - 1));
+        if (separatorBonus) {
+            score += separatorBonus;
+        }
+        else if (isUpper(target.charCodeAt(targetIndex)) && matchesSequenceLength === 0) {
+            score += 2;
+        }
+    }
+    return score;
+}
+function considerAsEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a === '/' || a === '\\') {
+        return b === '/' || b === '\\';
+    }
+    return false;
+}
+function scoreSeparatorAtPos(charCode) {
+    switch (charCode) {
+        case CharCode.Slash:
+        case CharCode.Backslash:
+            return 5;
+        case CharCode.Underline:
+        case CharCode.Dash:
+        case CharCode.Period:
+        case CharCode.Space:
+        case CharCode.SingleQuote:
+        case CharCode.DoubleQuote:
+        case CharCode.Colon:
+            return 4;
+        default:
+            return 0;
+    }
+}
+const NO_SCORE2 = [undefined, []];
+function scoreFuzzy2(target, query, patternStart = 0, wordStart = 0) {
+    const preparedQuery = query;
+    if (preparedQuery.values && preparedQuery.values.length > 1) {
+        return doScoreFuzzy2Multiple(target, preparedQuery.values, patternStart, wordStart);
+    }
+    return doScoreFuzzy2Single(target, query, patternStart, wordStart);
+}
+function doScoreFuzzy2Multiple(target, query, patternStart, wordStart) {
+    let totalScore = 0;
+    const totalMatches = [];
+    for (const queryPiece of query) {
+        const [score, matches] = doScoreFuzzy2Single(target, queryPiece, patternStart, wordStart);
+        if (typeof score !== 'number') {
+            return NO_SCORE2;
+        }
+        totalScore += score;
+        totalMatches.push(...matches);
+    }
+    return [totalScore, normalizeMatches(totalMatches)];
+}
+function doScoreFuzzy2Single(target, query, patternStart, wordStart) {
+    const score = fuzzyScore(query.original, query.originalLowercase, patternStart, target, target.toLowerCase(), wordStart, { firstMatchCanBeWeak: true, boostFullMatch: true });
+    if (!score) {
+        return NO_SCORE2;
+    }
+    return [score[0], createMatches$1(score)];
+}
+const NO_ITEM_SCORE = ( Object.freeze({ score: 0 }));
+const PATH_IDENTITY_SCORE = 1 << 18;
+const LABEL_PREFIX_SCORE_THRESHOLD = 1 << 17;
+const LABEL_SCORE_THRESHOLD = 1 << 16;
+function getCacheHash(label, description, allowNonContiguousMatches, query) {
+    const values = query.values ? query.values : [query];
+    const cacheHash = hash({
+        [query.normalized]: {
+            values: ( values.map(
+                v => ({ value: v.normalized, expectContiguousMatch: v.expectContiguousMatch })
+            )),
+            label,
+            description,
+            allowNonContiguousMatches
+        }
+    });
+    return cacheHash;
+}
+function scoreItemFuzzy(item, query, allowNonContiguousMatches, accessor, cache) {
+    if (!item || !query.normalized) {
+        return NO_ITEM_SCORE;
+    }
+    const label = accessor.getItemLabel(item);
+    if (!label) {
+        return NO_ITEM_SCORE;
+    }
+    const description = accessor.getItemDescription(item);
+    const cacheHash = getCacheHash(label, description, allowNonContiguousMatches, query);
+    const cached = cache[cacheHash];
+    if (cached) {
+        return cached;
+    }
+    const itemScore = doScoreItemFuzzy(label, description, accessor.getItemPath(item), query, allowNonContiguousMatches);
+    cache[cacheHash] = itemScore;
+    return itemScore;
+}
+function doScoreItemFuzzy(label, description, path, query, allowNonContiguousMatches) {
+    const preferLabelMatches = !path || !query.containsPathSeparator;
+    if (path && (isLinux ? query.pathNormalized === path : equalsIgnoreCase(query.pathNormalized, path))) {
+        return { score: PATH_IDENTITY_SCORE, labelMatch: [{ start: 0, end: label.length }], descriptionMatch: description ? [{ start: 0, end: description.length }] : undefined };
+    }
+    if (query.values && query.values.length > 1) {
+        return doScoreItemFuzzyMultiple(label, description, path, query.values, preferLabelMatches, allowNonContiguousMatches);
+    }
+    return doScoreItemFuzzySingle(label, description, path, query, preferLabelMatches, allowNonContiguousMatches);
+}
+function doScoreItemFuzzyMultiple(label, description, path, query, preferLabelMatches, allowNonContiguousMatches) {
+    let totalScore = 0;
+    const totalLabelMatches = [];
+    const totalDescriptionMatches = [];
+    for (const queryPiece of query) {
+        const { score, labelMatch, descriptionMatch } = doScoreItemFuzzySingle(label, description, path, queryPiece, preferLabelMatches, allowNonContiguousMatches);
+        if (score === NO_MATCH) {
+            return NO_ITEM_SCORE;
+        }
+        totalScore += score;
+        if (labelMatch) {
+            totalLabelMatches.push(...labelMatch);
+        }
+        if (descriptionMatch) {
+            totalDescriptionMatches.push(...descriptionMatch);
+        }
+    }
+    return {
+        score: totalScore,
+        labelMatch: normalizeMatches(totalLabelMatches),
+        descriptionMatch: normalizeMatches(totalDescriptionMatches)
+    };
+}
+function doScoreItemFuzzySingle(label, description, path, query, preferLabelMatches, allowNonContiguousMatches) {
+    if (preferLabelMatches || !description) {
+        const [labelScore, labelPositions] = scoreFuzzy(label, query.normalized, query.normalizedLowercase, allowNonContiguousMatches && !query.expectContiguousMatch);
+        if (labelScore) {
+            const labelPrefixMatch = matchesPrefix(query.normalized, label);
+            let baseScore;
+            if (labelPrefixMatch) {
+                baseScore = LABEL_PREFIX_SCORE_THRESHOLD;
+                const prefixLengthBoost = Math.round((query.normalized.length / label.length) * 100);
+                baseScore += prefixLengthBoost;
+            }
+            else {
+                baseScore = LABEL_SCORE_THRESHOLD;
+            }
+            return { score: baseScore + labelScore, labelMatch: labelPrefixMatch || createMatches(labelPositions) };
+        }
+    }
+    if (description) {
+        let descriptionPrefix = description;
+        if (!!path) {
+            descriptionPrefix = `${description}${sep}`;
+        }
+        const descriptionPrefixLength = descriptionPrefix.length;
+        const descriptionAndLabel = `${descriptionPrefix}${label}`;
+        const [labelDescriptionScore, labelDescriptionPositions] = scoreFuzzy(descriptionAndLabel, query.normalized, query.normalizedLowercase, allowNonContiguousMatches && !query.expectContiguousMatch);
+        if (labelDescriptionScore) {
+            const labelDescriptionMatches = createMatches(labelDescriptionPositions);
+            const labelMatch = [];
+            const descriptionMatch = [];
+            labelDescriptionMatches.forEach(h => {
+                if (h.start < descriptionPrefixLength && h.end > descriptionPrefixLength) {
+                    labelMatch.push({ start: 0, end: h.end - descriptionPrefixLength });
+                    descriptionMatch.push({ start: h.start, end: descriptionPrefixLength });
+                }
+                else if (h.start >= descriptionPrefixLength) {
+                    labelMatch.push({ start: h.start - descriptionPrefixLength, end: h.end - descriptionPrefixLength });
+                }
+                else {
+                    descriptionMatch.push(h);
+                }
+            });
+            return { score: labelDescriptionScore, labelMatch, descriptionMatch };
+        }
+    }
+    return NO_ITEM_SCORE;
+}
+function createMatches(offsets) {
+    const ret = [];
+    if (!offsets) {
+        return ret;
+    }
+    let last;
+    for (const pos of offsets) {
+        if (last && last.end === pos) {
+            last.end += 1;
+        }
+        else {
+            last = { start: pos, end: pos + 1 };
+            ret.push(last);
+        }
+    }
+    return ret;
+}
+function normalizeMatches(matches) {
+    const sortedMatches = matches.sort((matchA, matchB) => {
+        return matchA.start - matchB.start;
+    });
+    const normalizedMatches = [];
+    let currentMatch = undefined;
+    for (const match of sortedMatches) {
+        if (!currentMatch || !matchOverlaps(currentMatch, match)) {
+            currentMatch = match;
+            normalizedMatches.push(match);
+        }
+        else {
+            currentMatch.start = Math.min(currentMatch.start, match.start);
+            currentMatch.end = Math.max(currentMatch.end, match.end);
+        }
+    }
+    return normalizedMatches;
+}
+function matchOverlaps(matchA, matchB) {
+    if (matchA.end < matchB.start) {
+        return false;
+    }
+    if (matchB.end < matchA.start) {
+        return false;
+    }
+    return true;
+}
+function compareItemsByFuzzyScore(itemA, itemB, query, allowNonContiguousMatches, accessor, cache) {
+    const itemScoreA = scoreItemFuzzy(itemA, query, allowNonContiguousMatches, accessor, cache);
+    const itemScoreB = scoreItemFuzzy(itemB, query, allowNonContiguousMatches, accessor, cache);
+    const scoreA = itemScoreA.score;
+    const scoreB = itemScoreB.score;
+    if (scoreA === PATH_IDENTITY_SCORE || scoreB === PATH_IDENTITY_SCORE) {
+        if (scoreA !== scoreB) {
+            return scoreA === PATH_IDENTITY_SCORE ? -1 : 1;
+        }
+    }
+    if (scoreA > LABEL_SCORE_THRESHOLD || scoreB > LABEL_SCORE_THRESHOLD) {
+        if (scoreA !== scoreB) {
+            return scoreA > scoreB ? -1 : 1;
+        }
+        if (scoreA < LABEL_PREFIX_SCORE_THRESHOLD && scoreB < LABEL_PREFIX_SCORE_THRESHOLD) {
+            const comparedByMatchLength = compareByMatchLength(itemScoreA.labelMatch, itemScoreB.labelMatch);
+            if (comparedByMatchLength !== 0) {
+                return comparedByMatchLength;
+            }
+        }
+        const labelA = accessor.getItemLabel(itemA) || '';
+        const labelB = accessor.getItemLabel(itemB) || '';
+        if (labelA.length !== labelB.length) {
+            return labelA.length - labelB.length;
+        }
+    }
+    if (scoreA !== scoreB) {
+        return scoreA > scoreB ? -1 : 1;
+    }
+    const itemAHasLabelMatches = Array.isArray(itemScoreA.labelMatch) && itemScoreA.labelMatch.length > 0;
+    const itemBHasLabelMatches = Array.isArray(itemScoreB.labelMatch) && itemScoreB.labelMatch.length > 0;
+    if (itemAHasLabelMatches && !itemBHasLabelMatches) {
+        return -1;
+    }
+    else if (itemBHasLabelMatches && !itemAHasLabelMatches) {
+        return 1;
+    }
+    const itemAMatchDistance = computeLabelAndDescriptionMatchDistance(itemA, itemScoreA, accessor);
+    const itemBMatchDistance = computeLabelAndDescriptionMatchDistance(itemB, itemScoreB, accessor);
+    if (itemAMatchDistance && itemBMatchDistance && itemAMatchDistance !== itemBMatchDistance) {
+        return itemBMatchDistance > itemAMatchDistance ? -1 : 1;
+    }
+    return fallbackCompare(itemA, itemB, query, accessor);
+}
+function computeLabelAndDescriptionMatchDistance(item, score, accessor) {
+    let matchStart = -1;
+    let matchEnd = -1;
+    if (score.descriptionMatch && score.descriptionMatch.length) {
+        matchStart = score.descriptionMatch[0].start;
+    }
+    else if (score.labelMatch && score.labelMatch.length) {
+        matchStart = score.labelMatch[0].start;
+    }
+    if (score.labelMatch && score.labelMatch.length) {
+        matchEnd = score.labelMatch[score.labelMatch.length - 1].end;
+        if (score.descriptionMatch && score.descriptionMatch.length) {
+            const itemDescription = accessor.getItemDescription(item);
+            if (itemDescription) {
+                matchEnd += itemDescription.length;
+            }
+        }
+    }
+    else if (score.descriptionMatch && score.descriptionMatch.length) {
+        matchEnd = score.descriptionMatch[score.descriptionMatch.length - 1].end;
+    }
+    return matchEnd - matchStart;
+}
+function compareByMatchLength(matchesA, matchesB) {
+    if ((!matchesA && !matchesB) || ((!matchesA || !matchesA.length) && (!matchesB || !matchesB.length))) {
+        return 0;
+    }
+    if (!matchesB || !matchesB.length) {
+        return -1;
+    }
+    if (!matchesA || !matchesA.length) {
+        return 1;
+    }
+    const matchStartA = matchesA[0].start;
+    const matchEndA = matchesA[matchesA.length - 1].end;
+    const matchLengthA = matchEndA - matchStartA;
+    const matchStartB = matchesB[0].start;
+    const matchEndB = matchesB[matchesB.length - 1].end;
+    const matchLengthB = matchEndB - matchStartB;
+    return matchLengthA === matchLengthB ? 0 : matchLengthB < matchLengthA ? 1 : -1;
+}
+function fallbackCompare(itemA, itemB, query, accessor) {
+    const labelA = accessor.getItemLabel(itemA) || '';
+    const labelB = accessor.getItemLabel(itemB) || '';
+    const descriptionA = accessor.getItemDescription(itemA);
+    const descriptionB = accessor.getItemDescription(itemB);
+    const labelDescriptionALength = labelA.length + (descriptionA ? descriptionA.length : 0);
+    const labelDescriptionBLength = labelB.length + (descriptionB ? descriptionB.length : 0);
+    if (labelDescriptionALength !== labelDescriptionBLength) {
+        return labelDescriptionALength - labelDescriptionBLength;
+    }
+    const pathA = accessor.getItemPath(itemA);
+    const pathB = accessor.getItemPath(itemB);
+    if (pathA && pathB && pathA.length !== pathB.length) {
+        return pathA.length - pathB.length;
+    }
+    if (labelA !== labelB) {
+        return compareAnything(labelA, labelB, query.normalized);
+    }
+    if (descriptionA && descriptionB && descriptionA !== descriptionB) {
+        return compareAnything(descriptionA, descriptionB, query.normalized);
+    }
+    if (pathA && pathB && pathA !== pathB) {
+        return compareAnything(pathA, pathB, query.normalized);
+    }
+    return 0;
+}
+function queryExpectsExactMatch(query) {
+    return query.startsWith('"') && query.endsWith('"');
+}
+const MULTIPLE_QUERY_VALUES_SEPARATOR = ' ';
+function prepareQuery(original) {
+    if (typeof original !== 'string') {
+        original = '';
+    }
+    const originalLowercase = original.toLowerCase();
+    const { pathNormalized, normalized, normalizedLowercase } = normalizeQuery(original);
+    const containsPathSeparator = pathNormalized.indexOf(sep) >= 0;
+    const expectExactMatch = queryExpectsExactMatch(original);
+    let values = undefined;
+    const originalSplit = original.split(MULTIPLE_QUERY_VALUES_SEPARATOR);
+    if (originalSplit.length > 1) {
+        for (const originalPiece of originalSplit) {
+            const expectExactMatchPiece = queryExpectsExactMatch(originalPiece);
+            const { pathNormalized: pathNormalizedPiece, normalized: normalizedPiece, normalizedLowercase: normalizedLowercasePiece } = normalizeQuery(originalPiece);
+            if (normalizedPiece) {
+                if (!values) {
+                    values = [];
+                }
+                values.push({
+                    original: originalPiece,
+                    originalLowercase: originalPiece.toLowerCase(),
+                    pathNormalized: pathNormalizedPiece,
+                    normalized: normalizedPiece,
+                    normalizedLowercase: normalizedLowercasePiece,
+                    expectContiguousMatch: expectExactMatchPiece
+                });
+            }
+        }
+    }
+    return { original, originalLowercase, pathNormalized, normalized, normalizedLowercase, values, containsPathSeparator, expectContiguousMatch: expectExactMatch };
+}
+function normalizeQuery(original) {
+    let pathNormalized;
+    if (isWindows) {
+        pathNormalized = original.replace(/\//g, sep);
+    }
+    else {
+        pathNormalized = original.replace(/\\/g, sep);
+    }
+    const normalized = stripWildcards(pathNormalized).replace(/\s|"/g, '');
+    return {
+        pathNormalized,
+        normalized,
+        normalizedLowercase: normalized.toLowerCase()
+    };
+}
+function pieceToQuery(arg1) {
+    if (Array.isArray(arg1)) {
+        return prepareQuery(( arg1.map(piece => piece.original)).join(MULTIPLE_QUERY_VALUES_SEPARATOR));
+    }
+    return prepareQuery(arg1.original);
+}
+
+export { compareItemsByFuzzyScore, pieceToQuery, prepareQuery, scoreFuzzy, scoreFuzzy2, scoreItemFuzzy };

package/vscode/src/vs/platform/quickinput/browser/pickerQuickAccess.d.ts

@@ -0,0 +1,42 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable, DisposableStore, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IKeyMods, IQuickPickDidAcceptEvent, IQuickPickSeparator, IQuickPick, IQuickPickItem } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput";
+import { IQuickAccessProvider, IQuickAccessProviderRunOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickAccess";
+export declare enum TriggerAction {
+    NO_ACTION = 0,
+    CLOSE_PICKER = 1,
+    REFRESH_PICKER = 2,
+    REMOVE_ITEM = 3
+}
+export interface IPickerQuickAccessItem extends IQuickPickItem {
+    accept?(keyMods: IKeyMods, event: IQuickPickDidAcceptEvent): void;
+    trigger?(buttonIndex: number, keyMods: IKeyMods): TriggerAction | Promise<TriggerAction>;
+}
+export interface IPickerQuickAccessSeparator extends IQuickPickSeparator {
+    trigger?(buttonIndex: number, keyMods: IKeyMods): TriggerAction | Promise<TriggerAction>;
+}
+export interface IPickerQuickAccessProviderOptions<T extends IPickerQuickAccessItem> {
+    readonly canAcceptInBackground?: boolean;
+    readonly noResultsPick?: T | ((filter: string) => T);
+    readonly shouldSkipTrimPickFilter?: boolean;
+}
+export type Pick<T> = T | IQuickPickSeparator;
+export type PicksWithActive<T> = {
+    items: readonly Pick<T>[];
+    active?: T;
+};
+export type Picks<T> = readonly Pick<T>[] | PicksWithActive<T>;
+export type FastAndSlowPicks<T> = {
+    readonly picks: Picks<T>;
+    readonly additionalPicks: Promise<Picks<T>>;
+    readonly mergeDelay?: number;
+};
+export declare abstract class PickerQuickAccessProvider<T extends IPickerQuickAccessItem> extends Disposable implements IQuickAccessProvider {
+    private prefix;
+    protected options?: IPickerQuickAccessProviderOptions<T> | undefined;
+    constructor(prefix: string, options?: IPickerQuickAccessProviderOptions<T> | undefined);
+    provide(picker: IQuickPick<T, {
+        useSeparators: true;
+    }>, token: CancellationToken, runOptions?: IQuickAccessProviderRunOptions): IDisposable;
+    protected abstract _getPicks(filter: string, disposables: DisposableStore, token: CancellationToken, runOptions?: IQuickAccessProviderRunOptions): Picks<T> | Promise<Picks<T> | FastAndSlowPicks<T>> | FastAndSlowPicks<T> | null;
+}