@codingame/monaco-vscode-api 11.1.2 → 12.0.0

package/vscode/src/vs/editor/common/model.js

@@ -1,25 +1,52 @@
+
 import { equals } from '../../base/common/objects.js';
 
 var OverviewRulerLane;
-( (function(OverviewRulerLane) {
+(function (OverviewRulerLane) {
     OverviewRulerLane[OverviewRulerLane["Left"] = 1] = "Left";
     OverviewRulerLane[OverviewRulerLane["Center"] = 2] = "Center";
     OverviewRulerLane[OverviewRulerLane["Right"] = 4] = "Right";
     OverviewRulerLane[OverviewRulerLane["Full"] = 7] = "Full";
-})(OverviewRulerLane || (OverviewRulerLane = {})));
+})(OverviewRulerLane || (OverviewRulerLane = {}));
 var GlyphMarginLane;
-( (function(GlyphMarginLane) {
+(function (GlyphMarginLane) {
     GlyphMarginLane[GlyphMarginLane["Left"] = 1] = "Left";
     GlyphMarginLane[GlyphMarginLane["Center"] = 2] = "Center";
     GlyphMarginLane[GlyphMarginLane["Right"] = 3] = "Right";
-})(GlyphMarginLane || (GlyphMarginLane = {})));
+})(GlyphMarginLane || (GlyphMarginLane = {}));
+var MinimapPosition;
+(function (MinimapPosition) {
+    MinimapPosition[MinimapPosition["Inline"] = 1] = "Inline";
+    MinimapPosition[MinimapPosition["Gutter"] = 2] = "Gutter";
+})(MinimapPosition || (MinimapPosition = {}));
+var MinimapSectionHeaderStyle;
+(function (MinimapSectionHeaderStyle) {
+    MinimapSectionHeaderStyle[MinimapSectionHeaderStyle["Normal"] = 1] = "Normal";
+    MinimapSectionHeaderStyle[MinimapSectionHeaderStyle["Underlined"] = 2] = "Underlined";
+})(MinimapSectionHeaderStyle || (MinimapSectionHeaderStyle = {}));
 var InjectedTextCursorStops;
-( (function(InjectedTextCursorStops) {
+(function (InjectedTextCursorStops) {
     InjectedTextCursorStops[InjectedTextCursorStops["Both"] = 0] = "Both";
     InjectedTextCursorStops[InjectedTextCursorStops["Right"] = 1] = "Right";
     InjectedTextCursorStops[InjectedTextCursorStops["Left"] = 2] = "Left";
     InjectedTextCursorStops[InjectedTextCursorStops["None"] = 3] = "None";
-})(InjectedTextCursorStops || (InjectedTextCursorStops = {})));
+})(InjectedTextCursorStops || (InjectedTextCursorStops = {}));
+var EndOfLinePreference;
+(function (EndOfLinePreference) {
+    EndOfLinePreference[EndOfLinePreference["TextDefined"] = 0] = "TextDefined";
+    EndOfLinePreference[EndOfLinePreference["LF"] = 1] = "LF";
+    EndOfLinePreference[EndOfLinePreference["CRLF"] = 2] = "CRLF";
+})(EndOfLinePreference || (EndOfLinePreference = {}));
+var DefaultEndOfLine;
+(function (DefaultEndOfLine) {
+    DefaultEndOfLine[DefaultEndOfLine["LF"] = 1] = "LF";
+    DefaultEndOfLine[DefaultEndOfLine["CRLF"] = 2] = "CRLF";
+})(DefaultEndOfLine || (DefaultEndOfLine = {}));
+var EndOfLineSequence;
+(function (EndOfLineSequence) {
+    EndOfLineSequence[EndOfLineSequence["LF"] = 0] = "LF";
+    EndOfLineSequence[EndOfLineSequence["CRLF"] = 1] = "CRLF";
+})(EndOfLineSequence || (EndOfLineSequence = {}));
 class TextModelResolvedOptions {
     get originalIndentSize() {
         return this._indentSizeIsTabSize ? 'tabSize' : this.indentSize;
@@ -65,9 +92,31 @@ class FindMatch {
         this.matches = matches;
     }
 }
+var TrackedRangeStickiness;
+(function (TrackedRangeStickiness) {
+    TrackedRangeStickiness[TrackedRangeStickiness["AlwaysGrowsWhenTypingAtEdges"] = 0] = "AlwaysGrowsWhenTypingAtEdges";
+    TrackedRangeStickiness[TrackedRangeStickiness["NeverGrowsWhenTypingAtEdges"] = 1] = "NeverGrowsWhenTypingAtEdges";
+    TrackedRangeStickiness[TrackedRangeStickiness["GrowsOnlyWhenTypingBefore"] = 2] = "GrowsOnlyWhenTypingBefore";
+    TrackedRangeStickiness[TrackedRangeStickiness["GrowsOnlyWhenTypingAfter"] = 3] = "GrowsOnlyWhenTypingAfter";
+})(TrackedRangeStickiness || (TrackedRangeStickiness = {}));
 function isITextSnapshot(obj) {
     return (obj && typeof obj.read === 'function');
 }
+function isITextModel(obj) {
+    return Boolean(obj && obj.uri);
+}
+var PositionAffinity;
+(function (PositionAffinity) {
+    PositionAffinity[PositionAffinity["Left"] = 0] = "Left";
+    PositionAffinity[PositionAffinity["Right"] = 1] = "Right";
+    PositionAffinity[PositionAffinity["None"] = 2] = "None";
+    PositionAffinity[PositionAffinity["LeftOfInjectedText"] = 3] = "LeftOfInjectedText";
+    PositionAffinity[PositionAffinity["RightOfInjectedText"] = 4] = "RightOfInjectedText";
+})(PositionAffinity || (PositionAffinity = {}));
+var ModelConstants;
+(function (ModelConstants) {
+    ModelConstants[ModelConstants["FIRST_LINE_DETECTION_LENGTH_LIMIT"] = 1000] = "FIRST_LINE_DETECTION_LENGTH_LIMIT";
+})(ModelConstants || (ModelConstants = {}));
 class ValidAnnotatedEditOperation {
     constructor(identifier, range, text, forceMoveMarkers, isAutoWhitespaceEdit, _isTracked) {
         this.identifier = identifier;
@@ -96,4 +145,4 @@ function shouldSynchronizeModel(model) {
     return (!model.isTooLargeForSyncing() && !model.isForSimpleWidget);
 }
 
-export { ApplyEditsResult, FindMatch, GlyphMarginLane, InjectedTextCursorStops, OverviewRulerLane, SearchData, TextModelResolvedOptions, ValidAnnotatedEditOperation, isITextSnapshot, shouldSynchronizeModel };
+export { ApplyEditsResult, DefaultEndOfLine, EndOfLinePreference, EndOfLineSequence, FindMatch, GlyphMarginLane, InjectedTextCursorStops, MinimapPosition, MinimapSectionHeaderStyle, ModelConstants, OverviewRulerLane, PositionAffinity, SearchData, TextModelResolvedOptions, TrackedRangeStickiness, ValidAnnotatedEditOperation, isITextModel, isITextSnapshot, shouldSynchronizeModel };

package/vscode/src/vs/editor/common/modelLineProjectionData.d.ts

@@ -0,0 +1,43 @@
+import { WrappingIndent } from "./config/editorOptions.js";
+import { FontInfo } from "./config/fontInfo.js";
+import { Position } from "./core/position.js";
+import { InjectedTextOptions, PositionAffinity } from "./model.js";
+import { LineInjectedText } from "./textModelEvents.js";
+export declare class ModelLineProjectionData {
+    injectionOffsets: number[] | null;
+    injectionOptions: InjectedTextOptions[] | null;
+    breakOffsets: number[];
+    breakOffsetsVisibleColumn: number[];
+    wrappedTextIndentLength: number;
+    constructor(injectionOffsets: number[] | null, injectionOptions: InjectedTextOptions[] | null, breakOffsets: number[], breakOffsetsVisibleColumn: number[], wrappedTextIndentLength: number);
+    getOutputLineCount(): number;
+    getMinOutputOffset(outputLineIndex: number): number;
+    getLineLength(outputLineIndex: number): number;
+    getMaxOutputOffset(outputLineIndex: number): number;
+    translateToInputOffset(outputLineIndex: number, outputOffset: number): number;
+    translateToOutputPosition(inputOffset: number, affinity?: PositionAffinity): OutputPosition;
+    private offsetInInputWithInjectionsToOutputPosition;
+    normalizeOutputPosition(outputLineIndex: number, outputOffset: number, affinity: PositionAffinity): OutputPosition;
+    private outputPositionToOffsetInInputWithInjections;
+    private normalizeOffsetInInputWithInjectionsAroundInjections;
+    getInjectedText(outputLineIndex: number, outputOffset: number): InjectedText | null;
+    private getInjectedTextAtOffset;
+}
+export declare class InjectedText {
+    readonly options: InjectedTextOptions;
+    constructor(options: InjectedTextOptions);
+}
+export declare class OutputPosition {
+    outputLineIndex: number;
+    outputOffset: number;
+    constructor(outputLineIndex: number, outputOffset: number);
+    toString(): string;
+    toPosition(baseLineNumber: number): Position;
+}
+export interface ILineBreaksComputerFactory {
+    createLineBreaksComputer(fontInfo: FontInfo, tabSize: number, wrappingColumn: number, wrappingIndent: WrappingIndent, wordBreak: "normal" | "keepAll"): ILineBreaksComputer;
+}
+export interface ILineBreaksComputer {
+    addRequest(lineText: string, injectedText: LineInjectedText[] | null, previousLineBreakData: ModelLineProjectionData | null): void;
+    finalize(): (ModelLineProjectionData | null)[];
+}

package/vscode/src/vs/editor/common/modelLineProjectionData.js

@@ -1,6 +1,7 @@
+
 import { assertNever } from '../../base/common/assert.js';
 import { Position } from './core/position.js';
-import { InjectedTextCursorStops } from './model.js';
+import { PositionAffinity, InjectedTextCursorStops } from './model.js';
 
 class ModelLineProjectionData {
     constructor(injectionOffsets,
@@ -57,14 +58,14 @@ class ModelLineProjectionData {
         }
         return offsetInInput;
     }
-    translateToOutputPosition(inputOffset, affinity = 2 ) {
+    translateToOutputPosition(inputOffset, affinity = PositionAffinity.None) {
         let inputOffsetInInputWithInjection = inputOffset;
         if (this.injectionOffsets !== null) {
             for (let i = 0; i < this.injectionOffsets.length; i++) {
                 if (inputOffset < this.injectionOffsets[i]) {
                     break;
                 }
-                if (affinity !== 1  && inputOffset === this.injectionOffsets[i]) {
+                if (affinity !== PositionAffinity.Right && inputOffset === this.injectionOffsets[i]) {
                     break;
                 }
                 inputOffsetInInputWithInjection += this.injectionOptions[i].content.length;
@@ -72,7 +73,7 @@ class ModelLineProjectionData {
         }
         return this.offsetInInputWithInjectionsToOutputPosition(inputOffsetInInputWithInjection, affinity);
     }
-    offsetInInputWithInjectionsToOutputPosition(offsetInInputWithInjections, affinity = 2 ) {
+    offsetInInputWithInjectionsToOutputPosition(offsetInInputWithInjections, affinity = PositionAffinity.None) {
         let low = 0;
         let high = this.breakOffsets.length - 1;
         let mid = 0;
@@ -81,7 +82,7 @@ class ModelLineProjectionData {
             mid = low + ((high - low) / 2) | 0;
             const midStop = this.breakOffsets[mid];
             midStart = mid > 0 ? this.breakOffsets[mid - 1] : 0;
-            if (affinity === 0 ) {
+            if (affinity === PositionAffinity.Left) {
                 if (offsetInInputWithInjections <= midStart) {
                     high = mid - 1;
                 }
@@ -118,12 +119,12 @@ class ModelLineProjectionData {
                 return this.offsetInInputWithInjectionsToOutputPosition(normalizedOffsetInUnwrappedLine, affinity);
             }
         }
-        if (affinity === 0 ) {
+        if (affinity === PositionAffinity.Left) {
             if (outputLineIndex > 0 && outputOffset === this.getMinOutputOffset(outputLineIndex)) {
                 return ( new OutputPosition(outputLineIndex - 1, this.getMaxOutputOffset(outputLineIndex - 1)));
             }
         }
-        else if (affinity === 1 ) {
+        else if (affinity === PositionAffinity.Right) {
             const maxOutputLineIndex = this.getOutputLineCount() - 1;
             if (outputLineIndex < maxOutputLineIndex && outputOffset === this.getMaxOutputOffset(outputLineIndex)) {
                 return ( new OutputPosition(outputLineIndex + 1, this.getMinOutputOffset(outputLineIndex + 1)));
@@ -143,7 +144,7 @@ class ModelLineProjectionData {
         if (!injectedText) {
             return offsetInInputWithInjections;
         }
-        if (affinity === 2 ) {
+        if (affinity === PositionAffinity.None) {
             if (offsetInInputWithInjections === injectedText.offsetInInputWithInjections + injectedText.length
                 && hasRightCursorStop(this.injectionOptions[injectedText.injectedTextIndex].cursorStops)) {
                 return injectedText.offsetInInputWithInjections + injectedText.length;
@@ -167,7 +168,7 @@ class ModelLineProjectionData {
                 return result;
             }
         }
-        else if (affinity === 1  || affinity === 4 ) {
+        else if (affinity === PositionAffinity.Right || affinity === PositionAffinity.RightOfInjectedText) {
             let result = injectedText.offsetInInputWithInjections + injectedText.length;
             let index = injectedText.injectedTextIndex;
             while (index + 1 < this.injectionOffsets.length && this.injectionOffsets[index + 1] === this.injectionOffsets[index]) {
@@ -176,7 +177,7 @@ class ModelLineProjectionData {
             }
             return result;
         }
-        else if (affinity === 0  || affinity === 3 ) {
+        else if (affinity === PositionAffinity.Left || affinity === PositionAffinity.LeftOfInjectedText) {
             let result = injectedText.offsetInInputWithInjections;
             let index = injectedText.injectedTextIndex;
             while (index - 1 >= 0 && this.injectionOffsets[index - 1] === this.injectionOffsets[index]) {

package/vscode/src/vs/editor/common/services/editorBaseApi.d.ts

@@ -0,0 +1,8 @@
+export declare class KeyMod {
+    static readonly CtrlCmd: number;
+    static readonly Shift: number;
+    static readonly Alt: number;
+    static readonly WinCtrl: number;
+    static chord(firstPart: number, secondPart: number): number;
+}
+export declare function createMonacoBaseAPI(): typeof monaco;

package/vscode/src/vs/editor/common/services/editorBaseApi.js

@@ -1,6 +1,7 @@
+
 import { CancellationTokenSource } from '../../../base/common/cancellation.js';
 import { Emitter } from '../../../base/common/event.js';
-import { KeyChord } from '../../../base/common/keyCodes.js';
+import { KeyMod as KeyMod$1, KeyChord } from '../../../base/common/keyCodes.js';
 import { URI } from '../../../base/common/uri.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
@@ -9,10 +10,10 @@ import { Token } from '../languages.js';
 import { KeyCode, SelectionDirection, MarkerSeverity, MarkerTag } from '../standalone/standaloneEnums.js';
 
 class KeyMod {
-    static { this.CtrlCmd = 2048 ; }
-    static { this.Shift = 1024 ; }
-    static { this.Alt = 512 ; }
-    static { this.WinCtrl = 256 ; }
+    static { this.CtrlCmd = KeyMod$1.CtrlCmd; }
+    static { this.Shift = KeyMod$1.Shift; }
+    static { this.Alt = KeyMod$1.Alt; }
+    static { this.WinCtrl = KeyMod$1.WinCtrl; }
     static chord(firstPart, secondPart) {
         return KeyChord(firstPart, secondPart);
     }

package/vscode/src/vs/editor/common/services/editorSimpleWorker.d.ts

@@ -0,0 +1,72 @@
+import { IDisposable } from "../../../base/common/lifecycle.js";
+import { URI } from "../../../base/common/uri.js";
+import { IRequestHandler, IWorkerServer } from "../../../base/common/worker/simpleWorker.js";
+import { IRange } from "../core/range.js";
+import { IMirrorTextModel, IModelChangedEvent } from "../model/mirrorTextModel.js";
+import { IColorInformation, IInplaceReplaceSupportResult, ILink, TextEdit } from "../languages.js";
+import { DiffAlgorithmName, IDiffComputationResult, IUnicodeHighlightsResult } from "./editorWorker.js";
+import { EditorWorkerHost } from "./editorWorkerHost.js";
+import { UnicodeHighlighterOptions } from "./unicodeTextModelHighlighter.js";
+import { IChange } from "../diff/legacyLinesDiffComputer.js";
+import { ILinesDiffComputerOptions } from "../diff/linesDiffComputer.js";
+import { IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { FindSectionHeaderOptions, SectionHeader } from "./findSectionHeaders.js";
+import { IRawModelData, IWorkerTextModelSyncChannelServer } from "./textModelSync/textModelSync.protocol.js";
+import { ICommonModel } from "./textModelSync/textModelSync.impl.js";
+export interface IMirrorModel extends IMirrorTextModel {
+    readonly uri: URI;
+    readonly version: number;
+    getValue(): string;
+}
+export interface IWorkerContext<H = undefined> {
+    host: H;
+    getMirrorModels(): IMirrorModel[];
+}
+export interface IWordRange {
+    readonly start: number;
+    readonly end: number;
+}
+export interface IForeignModuleFactory {
+    (ctx: IWorkerContext, createData: any): any;
+}
+export declare class BaseEditorSimpleWorker implements IDisposable, IWorkerTextModelSyncChannelServer, IRequestHandler {
+    _requestHandlerBrand: any;
+    private readonly _workerTextModelSyncServer;
+    constructor();
+    dispose(): void;
+    protected _getModel(uri: string): ICommonModel | undefined;
+    protected _getModels(): ICommonModel[];
+    $acceptNewModel(data: IRawModelData): void;
+    $acceptModelChanged(uri: string, e: IModelChangedEvent): void;
+    $acceptRemovedModel(uri: string): void;
+    $computeUnicodeHighlights(url: string, options: UnicodeHighlighterOptions, range?: IRange): Promise<IUnicodeHighlightsResult>;
+    $findSectionHeaders(url: string, options: FindSectionHeaderOptions): Promise<SectionHeader[]>;
+    $computeDiff(originalUrl: string, modifiedUrl: string, options: IDocumentDiffProviderOptions, algorithm: DiffAlgorithmName): Promise<IDiffComputationResult | null>;
+    private static computeDiff;
+    private static _modelsAreIdentical;
+    $computeDirtyDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): Promise<IChange[] | null>;
+    private static readonly _diffLimit;
+    $computeMoreMinimalEdits(modelUrl: string, edits: TextEdit[], pretty: boolean): Promise<TextEdit[]>;
+    $computeHumanReadableDiff(modelUrl: string, edits: TextEdit[], options: ILinesDiffComputerOptions): TextEdit[];
+    $computeLinks(modelUrl: string): Promise<ILink[] | null>;
+    $computeDefaultDocumentColors(modelUrl: string): Promise<IColorInformation[] | null>;
+    private static readonly _suggestionsLimit;
+    $textualSuggest(modelUrls: string[], leadingWord: string | undefined, wordDef: string, wordDefFlags: string): Promise<{
+        words: string[];
+        duration: number;
+    } | null>;
+    $computeWordRanges(modelUrl: string, range: IRange, wordDef: string, wordDefFlags: string): Promise<{
+        [word: string]: IRange[];
+    }>;
+    $navigateValueSet(modelUrl: string, range: IRange, up: boolean, wordDef: string, wordDefFlags: string): Promise<IInplaceReplaceSupportResult | null>;
+}
+export declare class EditorSimpleWorker extends BaseEditorSimpleWorker {
+    private readonly _host;
+    private readonly _foreignModuleFactory;
+    private _foreignModule;
+    constructor(_host: EditorWorkerHost, _foreignModuleFactory: IForeignModuleFactory | null);
+    $ping(): Promise<string>;
+    $loadForeignModule(moduleId: string, createData: any, foreignHostMethods: string[]): Promise<string[]>;
+    $fmr(method: string, args: any[]): Promise<any>;
+}
+export declare function create(workerServer: IWorkerServer): IRequestHandler;

package/vscode/src/vs/editor/common/services/editorSimpleWorker.js

@@ -1,3 +1,4 @@
+
 import { stringDiff } from '../../../base/common/diff/diff.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';

package/vscode/src/vs/editor/common/services/editorWorker.d.ts

@@ -1,20 +1,16 @@
-import { ServiceIdentifier } from '../../../platform/instantiation/common/instantiation.js';
-import { URI } from '../../../base/common/uri.js';
-import { IRange } from '../core/range.js';
-import { IDocumentDiffProviderOptions, IDocumentDiff } from '../diff/documentDiffProvider.js';
-import { IChange } from '../diff/legacyLinesDiffComputer.js';
-import { TextEdit, IInplaceReplaceSupportResult, IColorInformation } from '../languages.js';
-import { UnicodeHighlighterOptions } from './unicodeTextModelHighlighter.js';
-import { FindSectionHeaderOptions, SectionHeader } from './findSectionHeaders.js';
-
-type DiffAlgorithmName = 'legacy' | 'advanced';
-
-declare const IEditorWorkerService: ServiceIdentifier<IEditorWorkerService>;
-interface IEditorWorkerService {
+import { URI } from "../../../base/common/uri.js";
+import { IRange } from "../core/range.js";
+import { IDocumentDiff, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { IChange } from "../diff/legacyLinesDiffComputer.js";
+import { IColorInformation, IInplaceReplaceSupportResult, TextEdit } from "../languages.js";
+import { UnicodeHighlighterOptions } from "./unicodeTextModelHighlighter.js";
+import { SectionHeader, FindSectionHeaderOptions } from "./findSectionHeaders.js";
+export declare const IEditorWorkerService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IEditorWorkerService>;
+export type DiffAlgorithmName = "legacy" | "advanced";
+export interface IEditorWorkerService {
     readonly _serviceBrand: undefined;
     canComputeUnicodeHighlights(uri: URI): boolean;
     computedUnicodeHighlights(uri: URI, options: UnicodeHighlighterOptions, range?: IRange): Promise<IUnicodeHighlightsResult>;
-    /** Implementation in {@link BaseEditorSimpleWorker.computeDiff} */
     computeDiff(original: URI, modified: URI, options: IDocumentDiffProviderOptions, algorithm: DiffAlgorithmName): Promise<IDocumentDiff | null>;
     canComputeDirtyDiff(original: URI, modified: URI): boolean;
     computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<IChange[] | null>;
@@ -29,12 +25,40 @@ interface IEditorWorkerService {
     findSectionHeaders(uri: URI, options: FindSectionHeaderOptions): Promise<SectionHeader[]>;
     computeDefaultDocumentColors(uri: URI): Promise<IColorInformation[] | null>;
 }
-interface IUnicodeHighlightsResult {
+export interface IDiffComputationResult {
+    quitEarly: boolean;
+    changes: ILineChange[];
+    identical: boolean;
+    moves: ITextMove[];
+}
+export type ILineChange = [
+    originalStartLine: number,
+    originalEndLine: number,
+    modifiedStartLine: number,
+    modifiedEndLine: number,
+    charChanges: ICharChange[] | undefined
+];
+export type ICharChange = [
+    originalStartLine: number,
+    originalStartColumn: number,
+    originalEndLine: number,
+    originalEndColumn: number,
+    modifiedStartLine: number,
+    modifiedStartColumn: number,
+    modifiedEndLine: number,
+    modifiedEndColumn: number
+];
+export type ITextMove = [
+    originalStartLine: number,
+    originalEndLine: number,
+    modifiedStartLine: number,
+    modifiedEndLine: number,
+    changes: ILineChange[]
+];
+export interface IUnicodeHighlightsResult {
     ranges: IRange[];
     hasMore: boolean;
     nonBasicAsciiCharacterCount: number;
     invisibleCharacterCount: number;
     ambiguousCharacterCount: number;
 }
-
-export { type DiffAlgorithmName, IEditorWorkerService, type IUnicodeHighlightsResult };

package/vscode/src/vs/editor/common/services/editorWorker.js

@@ -1,3 +1,4 @@
+
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 
 const IEditorWorkerService = ( createDecorator('editorWorkerService'));

package/vscode/src/vs/editor/common/services/editorWorkerBootstrap.d.ts

@@ -0,0 +1,2 @@
+import { IForeignModuleFactory } from "./editorSimpleWorker.js";
+export declare function initialize(factory: IForeignModuleFactory | null): void;

package/vscode/src/vs/editor/common/services/editorWorkerBootstrap.js

@@ -1,3 +1,4 @@
+
 import { SimpleWorkerServer } from '../../../base/common/worker/simpleWorker.js';
 import { EditorSimpleWorker } from './editorSimpleWorker.js';
 import { EditorWorkerHost } from './editorWorkerHost.js';

package/vscode/src/vs/editor/common/services/editorWorkerHost.d.ts

@@ -0,0 +1,7 @@
+import { IWorkerServer, IWorkerClient } from "../../../base/common/worker/simpleWorker.js";
+export declare abstract class EditorWorkerHost {
+    static CHANNEL_NAME: string;
+    static getChannel(workerServer: IWorkerServer): EditorWorkerHost;
+    static setChannel(workerClient: IWorkerClient<any>, obj: EditorWorkerHost): void;
+    abstract $fhr(method: string, args: any[]): Promise<any>;
+}

package/vscode/src/vs/editor/common/services/editorWorkerHost.js

@@ -1,3 +1,5 @@
+
+
 class EditorWorkerHost {
     static { this.CHANNEL_NAME = 'editorWorkerHost'; }
     static getChannel(workerServer) {

package/vscode/src/vs/editor/common/services/findSectionHeaders.d.ts

@@ -1,28 +1,18 @@
-import { IRange } from '../core/range.js';
-import { FoldingRules } from '../languages/languageConfiguration.js';
-
-interface FindSectionHeaderOptions {
+import { IRange } from "../core/range.js";
+import { FoldingRules } from "../languages/languageConfiguration.js";
+export interface ISectionHeaderFinderTarget {
+    getLineCount(): number;
+    getLineContent(lineNumber: number): string;
+}
+export interface FindSectionHeaderOptions {
     foldingRules?: FoldingRules;
     findRegionSectionHeaders: boolean;
     findMarkSectionHeaders: boolean;
 }
-interface SectionHeader {
-    /**
-     * The location of the header text in the text model.
-     */
+export interface SectionHeader {
     range: IRange;
-    /**
-     * The section header text.
-     */
     text: string;
-    /**
-     * Whether the section header includes a separator line.
-     */
     hasSeparatorLine: boolean;
-    /**
-     * This section should be omitted before rendering if it's not in a comment.
-     */
     shouldBeInComments: boolean;
 }
-
-export type { FindSectionHeaderOptions, SectionHeader };
+export declare function findSectionHeaders(model: ISectionHeaderFinderTarget, options: FindSectionHeaderOptions): SectionHeader[];

package/vscode/src/vs/editor/common/services/findSectionHeaders.js

@@ -1,3 +1,5 @@
+
+
 const markRegex = ( new RegExp('\\bMARK:\\s*(.*)$', 'd'));
 const trimDashesRegex = /^-+|-+$/g;
 function findSectionHeaders(model, options) {

package/vscode/src/vs/editor/common/services/getIconClasses.d.ts

@@ -0,0 +1,8 @@
+import { URI, URI as uri } from "../../../base/common/uri.js";
+import { ILanguageService } from "../languages/language.js";
+import { IModelService } from "./model.js";
+import { FileKind } from "../../../platform/files/common/files.js";
+import { ThemeIcon } from "../../../base/common/themables.js";
+export declare function getIconClasses(modelService: IModelService, languageService: ILanguageService, resource: uri | undefined, fileKind?: FileKind, icon?: ThemeIcon | URI): string[];
+export declare function getIconClassesForLanguageId(languageId: string): string[];
+export declare function fileIconSelectorEscape(str: string): string;

package/vscode/src/vs/editor/common/services/getIconClasses.js

@@ -1,3 +1,4 @@
+
 import { Schemas } from '../../../base/common/network.js';
 import { DataUri } from '../../../base/common/resources.js';
 import { URI } from '../../../base/common/uri.js';
@@ -23,13 +24,13 @@ function getIconClasses(modelService, languageService, resource, fileKind, icon)
         else {
             const match = resource.path.match(fileIconDirectoryRegex);
             if (match) {
-                name = cssEscape(match[2].toLowerCase());
+                name = fileIconSelectorEscape(match[2].toLowerCase());
                 if (match[1]) {
-                    classes.push(`${cssEscape(match[1].toLowerCase())}-name-dir-icon`);
+                    classes.push(`${fileIconSelectorEscape(match[1].toLowerCase())}-name-dir-icon`);
                 }
             }
             else {
-                name = cssEscape(resource.authority.toLowerCase());
+                name = fileIconSelectorEscape(resource.authority.toLowerCase());
             }
         }
         if (fileKind === FileKind.ROOT_FOLDER) {
@@ -52,14 +53,14 @@ function getIconClasses(modelService, languageService, resource, fileKind, icon)
             }
             const detectedLanguageId = detectLanguageId(modelService, languageService, resource);
             if (detectedLanguageId) {
-                classes.push(`${cssEscape(detectedLanguageId)}-lang-file-icon`);
+                classes.push(`${fileIconSelectorEscape(detectedLanguageId)}-lang-file-icon`);
             }
         }
     }
     return classes;
 }
 function getIconClassesForLanguageId(languageId) {
-    return ['file-icon', `${cssEscape(languageId)}-lang-file-icon`];
+    return ['file-icon', `${fileIconSelectorEscape(languageId)}-lang-file-icon`];
 }
 function detectLanguageId(modelService, languageService, resource) {
     if (!resource) {
@@ -84,8 +85,8 @@ function detectLanguageId(modelService, languageService, resource) {
     }
     return languageService.guessLanguageIdByFilepathOrFirstLine(resource);
 }
-function cssEscape(str) {
+function fileIconSelectorEscape(str) {
     return str.replace(/[\s]/g, '/');
 }
 
-export { getIconClasses, getIconClassesForLanguageId };
+export { fileIconSelectorEscape, getIconClasses, getIconClassesForLanguageId };

package/vscode/src/vs/editor/common/services/languageFeatureDebounce.d.ts

@@ -1,9 +1,9 @@
-import { ServiceIdentifier } from '../../../platform/instantiation/common/instantiation.js';
-import { LanguageFeatureRegistry } from '../languageFeatureRegistry.js';
-import { ITextModel } from '../model.js';
-
-declare const ILanguageFeatureDebounceService: ServiceIdentifier<ILanguageFeatureDebounceService>;
-interface ILanguageFeatureDebounceService {
+import { LanguageFeatureRegistry } from "../languageFeatureRegistry.js";
+import { ITextModel } from "../model.js";
+import { IEnvironmentService } from "../../../platform/environment/common/environment.service.js";
+import { ILogService } from "../../../platform/log/common/log.service.js";
+export declare const ILanguageFeatureDebounceService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ILanguageFeatureDebounceService>;
+export interface ILanguageFeatureDebounceService {
     readonly _serviceBrand: undefined;
     for(feature: LanguageFeatureRegistry<object>, debugName: string, config?: {
         min?: number;
@@ -11,10 +11,21 @@ interface ILanguageFeatureDebounceService {
         salt?: string;
     }): IFeatureDebounceInformation;
 }
-interface IFeatureDebounceInformation {
+export interface IFeatureDebounceInformation {
     get(model: ITextModel): number;
     update(model: ITextModel, value: number): number;
     default(): number;
 }
-
-export { type IFeatureDebounceInformation, ILanguageFeatureDebounceService };
+export declare class LanguageFeatureDebounceService implements ILanguageFeatureDebounceService {
+    private readonly _logService;
+    _serviceBrand: undefined;
+    private readonly _data;
+    private readonly _isDev;
+    constructor(_logService: ILogService, envService: IEnvironmentService);
+    for(feature: LanguageFeatureRegistry<object>, name: string, config?: {
+        min?: number;
+        max?: number;
+        key?: string;
+    }): IFeatureDebounceInformation;
+    private _overallAverage;
+}

package/vscode/src/vs/editor/common/services/languageFeatureDebounce.js

@@ -1,16 +1,17 @@
+
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { doHash } from '../../../base/common/hash.js';
 import { LRUCache } from '../../../base/common/map.js';
 import { clamp, SlidingWindowAverage, MovingAverage } from '../../../base/common/numbers.js';
 import { IEnvironmentService } from '../../../platform/environment/common/environment.service.js';
-import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
+import { registerSingleton, InstantiationType } from '../../../platform/instantiation/common/extensions.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
 import { matchesScheme } from '../../../base/common/network.js';
 
 const ILanguageFeatureDebounceService = ( createDecorator('ILanguageFeatureDebounceService'));
 var IdentityHash;
-( (function(IdentityHash) {
+(function (IdentityHash) {
     const _hashes = ( new WeakMap());
     let pool = 0;
     function of(obj) {
@@ -22,7 +23,7 @@ var IdentityHash;
         return value;
     }
     IdentityHash.of = of;
-})(IdentityHash || (IdentityHash = {})));
+})(IdentityHash || (IdentityHash = {}));
 class NullDebounceInformation {
     constructor(_default) {
         this._default = _default;
@@ -125,6 +126,6 @@ LanguageFeatureDebounceService = ( __decorate([
     ( __param(0, ILogService)),
     ( __param(1, IEnvironmentService))
 ], LanguageFeatureDebounceService));
-registerSingleton(ILanguageFeatureDebounceService, LanguageFeatureDebounceService, 1 );
+registerSingleton(ILanguageFeatureDebounceService, LanguageFeatureDebounceService, InstantiationType.Delayed);
 
 export { ILanguageFeatureDebounceService, LanguageFeatureDebounceService };