@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsImpl.d.ts

@@ -23,6 +23,10 @@ export declare class BracketPairsTextModelPart extends Disposable implements IBr
     handleDidChangeBackgroundTokenizationState(): void;
     handleDidChangeTokens(e: IModelTokensChangedEvent): void;
     private updateBracketPairsTree;
+    /**
+     * Returns all bracket pairs that intersect the given range.
+     * The result is sorted by the start position.
+    */
     getBracketPairsInRange(range: Range): CallbackIterable<BracketPairInfo>;
     getBracketPairsInRangeWithMinIndentation(range: Range): CallbackIterable<BracketPairWithMinIndentationInfo>;
     getBracketsInRange(range: Range, onlyColorizedBrackets?: boolean): CallbackIterable<BracketInfo>;

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/ast.d.ts

@@ -11,21 +11,54 @@ export declare enum AstNodeKind {
     List = 4
 }
 export type AstNode = PairAstNode | ListAstNode | BracketAstNode | InvalidBracketAstNode | TextAstNode;
+/**
+ * The base implementation for all AST nodes.
+*/
 declare abstract class BaseAstNode {
     abstract readonly kind: AstNodeKind;
     abstract readonly childrenLength: number;
+    /**
+     * Might return null even if {@link idx} is smaller than {@link BaseAstNode.childrenLength}.
+    */
     abstract getChild(idx: number): AstNode | null;
+    /**
+     * Try to avoid using this property, as implementations might need to allocate the resulting array.
+    */
     abstract readonly children: readonly AstNode[];
+    /**
+     * Represents the set of all (potentially) missing opening bracket ids in this node.
+     * E.g. in `{ ] ) }` that set is {`[`, `(` }.
+    */
     abstract readonly missingOpeningBracketIds: SmallImmutableSet<OpeningBracketId>;
+    /**
+     * In case of a list, determines the height of the (2,3) tree.
+    */
     abstract readonly listHeight: number;
     protected _length: Length;
+    /**
+     * The length of the entire node, which should equal the sum of lengths of all children.
+    */
     get length(): Length;
     constructor(length: Length);
+    /**
+     * @param openBracketIds The set of all opening brackets that have not yet been closed.
+     */
     abstract canBeReused(openBracketIds: SmallImmutableSet<OpeningBracketId>): boolean;
+    /**
+     * Flattens all lists in this AST. Only for debugging.
+     */
     abstract flattenLists(): AstNode;
+    /**
+     * Creates a deep clone.
+     */
     abstract deepClone(): AstNode;
     abstract computeMinIndentation(offset: Length, textModel: ITextModel): number;
 }
+/**
+ * Represents a bracket pair including its child (e.g. `{ ... }`).
+ * Might be unclosed.
+ * Immutable, if all children are immutable.
+*/
 export declare class PairAstNode extends BaseAstNode {
     readonly openingBracket: BracketAstNode;
     readonly child: AstNode | null;
@@ -36,6 +69,9 @@ export declare class PairAstNode extends BaseAstNode {
     get listHeight(): number;
     get childrenLength(): number;
     getChild(idx: number): AstNode | null;
+    /**
+     * Avoid using this property, it allocates an array!
+    */
     get children(): AstNode[];
     private constructor();
     canBeReused(openBracketIds: SmallImmutableSet<OpeningBracketId>): boolean;
@@ -46,12 +82,18 @@ export declare class PairAstNode extends BaseAstNode {
 export declare abstract class ListAstNode extends BaseAstNode {
     readonly listHeight: number;
     private _missingOpeningBracketIds;
+    /**
+     * This method uses more memory-efficient list nodes that can only store 2 or 3 children.
+    */
     static create23(item1: AstNode, item2: AstNode, item3: AstNode | null, immutable?: boolean): ListAstNode;
     static create(items: AstNode[], immutable?: boolean): ListAstNode;
     static getEmpty(): ImmutableArrayListAstNode;
     get kind(): AstNodeKind.List;
     get missingOpeningBracketIds(): SmallImmutableSet<OpeningBracketId>;
     private cachedMinIndentation;
+    /**
+     * Use ListAstNode.create.
+    */
     constructor(length: Length, listHeight: number, _missingOpeningBracketIds: SmallImmutableSet<OpeningBracketId>);
     protected throwIfImmutable(): void;
     protected abstract setChild(idx: number, child: AstNode): void;
@@ -61,12 +103,18 @@ export declare abstract class ListAstNode extends BaseAstNode {
     handleChildrenChanged(): void;
     flattenLists(): ListAstNode;
     computeMinIndentation(offset: Length, textModel: ITextModel): number;
+    /**
+     * Creates a shallow clone that is mutable, or itself if it is already mutable.
+     */
     abstract toMutable(): ListAstNode;
     abstract appendChildOfSameHeight(node: AstNode): void;
     abstract unappendChild(): AstNode | undefined;
     abstract prependChildOfSameHeight(node: AstNode): void;
     abstract unprependChild(): AstNode | undefined;
 }
+/**
+ * For debugging.
+*/
 declare class ArrayListAstNode extends ListAstNode {
     private readonly _children;
     get childrenLength(): number;
@@ -81,6 +129,9 @@ declare class ArrayListAstNode extends ListAstNode {
     unprependChild(): AstNode | undefined;
     toMutable(): ListAstNode;
 }
+/**
+ * Immutable, if all children are immutable.
+*/
 declare class ImmutableArrayListAstNode extends ArrayListAstNode {
     toMutable(): ListAstNode;
     protected throwIfImmutable(): void;
@@ -101,6 +152,10 @@ export declare class TextAstNode extends ImmutableLeafAstNode {
 }
 export declare class BracketAstNode extends ImmutableLeafAstNode {
     readonly bracketInfo: BracketKind;
+    /**
+     * In case of a opening bracket, this is the id of the opening bracket.
+     * In case of a closing bracket, this contains the ids of all opening brackets it can close.
+    */
     readonly bracketIds: SmallImmutableSet<OpeningBracketId>;
     static create(length: Length, bracketInfo: BracketKind, bracketIds: SmallImmutableSet<OpeningBracketId>): BracketAstNode;
     get kind(): AstNodeKind.Bracket;

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/beforeEditPositionMapper.d.ts

@@ -14,8 +14,18 @@ export declare class BeforeEditPositionMapper {
     private deltaOldToNewColumnCount;
     private deltaLineIdxInOld;
     private readonly edits;
+    /**
+     * @param edits Must be sorted by offset in ascending order.
+    */
     constructor(edits: readonly TextEditInfo[]);
+    /**
+     * @param offset Must be equal to or greater than the last offset this method has been called with.
+    */
     getOffsetBeforeChange(offset: Length): Length;
+    /**
+     * @param offset Must be equal to or greater than the last offset this method has been called with.
+     * Returns null if there is no edit anymore.
+    */
     getDistanceToNextChange(offset: Length): Length | null;
     private translateOldToCur;
     private translateCurToOld;

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/bracketPairsTree.d.ts

@@ -24,6 +24,9 @@ export declare class BracketPairsTree extends Disposable {
     handleContentChanged(change: IModelContentChangedEvent): void;
     private handleEdits;
     private flushQueue;
+    /**
+     * @pure (only if isPure = true)
+    */
     private parseDocumentFromTextBuffer;
     getBracketsInRange(range: Range, onlyColorizedBrackets: boolean): CallbackIterable<BracketInfo>;
     getBracketPairsInRange(range: Range, includeMinIndentation: boolean): CallbackIterable<BracketPairWithMinIndentationInfo>;

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/brackets.d.ts

@@ -8,6 +8,9 @@ export declare class BracketTokens {
     private _regExpGlobal;
     constructor(map: Map<string, Token>);
     getRegExpStr(): string | null;
+    /**
+     * Returns null if there is no such regexp (because there are no brackets).
+    */
     get regExpGlobal(): RegExp | null;
     getToken(value: string): Token | undefined;
     findClosingTokenText(openingBracketIds: SmallImmutableSet<OpeningBracketId>): string | undefined;

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/concat23Trees.d.ts

@@ -1,3 +1,9 @@
 import { AstNode } from "./ast.js";
+/**
+ * Concatenates a list of (2,3) AstNode's into a single (2,3) AstNode.
+ * This mutates the items of the input array!
+ * If all items have the same height, this method has runtime O(items.length).
+ * Otherwise, it has runtime O(items.length * max(log(items.length), items.max(i => i.height))).
+*/
 export declare function concat23Trees(items: AstNode[]): AstNode | null;
 export declare function concat23TreesOfSameHeight(items: AstNode[], createImmutableLists?: boolean): AstNode | null;

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/length.d.ts

@@ -1,7 +1,14 @@
 import { Position } from "../../../core/position.js";
 import { Range } from "../../../core/range.js";
 import { TextLength } from "../../../core/text/textLength.js";
+/**
+ * The end must be greater than or equal to the start.
+*/
 export declare function lengthDiff(startLineCount: number, startColumnCount: number, endLineCount: number, endColumnCount: number): Length;
+/**
+ * Represents a non-negative length in terms of line and column count.
+ * Does not allocate.
+*/
 export type Length = {
     _brand: "Length";
 };
@@ -10,10 +17,16 @@ export declare function lengthIsZero(length: Length): boolean;
 export declare function toLength(lineCount: number, columnCount: number): Length;
 export declare function lengthToObj(length: Length): TextLength;
 export declare function lengthGetLineCount(length: Length): number;
+/**
+ * Returns the amount of columns of the given length, assuming that it does not span any line.
+*/
 export declare function lengthGetColumnCountIfZeroLineCount(length: Length): number;
 export declare function lengthAdd(length1: Length, length2: Length): Length;
 export declare function sumLengths<T>(items: readonly T[], lengthFn: (item: T) => Length): Length;
 export declare function lengthEquals(length1: Length, length2: Length): boolean;
+/**
+ * Returns a non negative length `result` such that `lengthAdd(length1, result) = length2`, or zero if such length does not exist.
+ */
 export declare function lengthDiffNonNegative(length1: Length, length2: Length): Length;
 export declare function lengthLessThan(length1: Length, length2: Length): boolean;
 export declare function lengthLessThanEqual(length1: Length, length2: Length): boolean;
@@ -25,5 +38,8 @@ export declare function lengthOfRange(range: Range): TextLength;
 export declare function lengthCompare(length1: Length, length2: Length): number;
 export declare function lengthOfString(str: string): Length;
 export declare function lengthOfStringObj(str: string): TextLength;
+/**
+ * Computes a numeric hash of the given length.
+*/
 export declare function lengthHash(length: Length): number;
 export declare function lengthMax(length1: Length, length2: Length): Length;

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/nodeReader.d.ts

@@ -1,11 +1,19 @@
 import { AstNode } from "./ast.js";
 import { Length } from "./length.js";
+/**
+ * Allows to efficiently find a longest child at a given offset in a fixed node.
+ * The requested offsets must increase monotonously.
+*/
 export declare class NodeReader {
     private readonly nextNodes;
     private readonly offsets;
     private readonly idxs;
     private lastOffset;
     constructor(node: AstNode);
+    /**
+     * Returns the longest node at `offset` that satisfies the predicate.
+     * @param offset must be greater than or equal to the last offset this method has been called with!
+    */
     readLongestNodeAt(offset: Length, predicate: (node: AstNode) => boolean): AstNode | undefined;
     private nextNodeAfterCurrent;
 }

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/parser.d.ts

@@ -1,4 +1,7 @@
 import { AstNode } from "./ast.js";
 import { TextEditInfo } from "./beforeEditPositionMapper.js";
 import { Tokenizer } from "./tokenizer.js";
+/**
+ * Non incrementally built ASTs are immutable.
+*/
 export declare function parseDocument(tokenizer: Tokenizer, edits: TextEditInfo[], oldNode: AstNode | undefined, createImmutableLists: boolean): AstNode;

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/smallImmutableSet.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Represents an immutable set that works best for a small number of elements (less than 32).
+ * It uses bits to encode element membership efficiently.
+*/
 export declare class SmallImmutableSet<T> {
     private readonly items;
     private readonly additionalItems;
@@ -16,6 +20,9 @@ export interface IDenseKeyProvider<T> {
     getKey(value: T): number;
 }
 export declare const identityKeyProvider: IDenseKeyProvider<number>;
+/**
+ * Assigns values a unique incrementing key.
+*/
 export declare class DenseKeyProvider<T> {
     private readonly items;
     getKey(value: T): number;

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/tokenizer.d.ts

@@ -20,10 +20,32 @@ export type OpeningBracketId = number;
 export declare class Token {
     readonly length: Length;
     readonly kind: TokenKind;
+    /**
+     * If this token is an opening bracket, this is the id of the opening bracket.
+     * If this token is a closing bracket, this is the id of the first opening bracket that is closed by this bracket.
+     * Otherwise, it is -1.
+     */
     readonly bracketId: OpeningBracketId;
+    /**
+     * If this token is an opening bracket, this just contains `bracketId`.
+     * If this token is a closing bracket, this lists all opening bracket ids, that it closes.
+     * Otherwise, it is empty.
+     */
     readonly bracketIds: SmallImmutableSet<OpeningBracketId>;
     readonly astNode: BracketAstNode | TextAstNode | undefined;
-    constructor(length: Length, kind: TokenKind, bracketId: OpeningBracketId, bracketIds: SmallImmutableSet<OpeningBracketId>, astNode: BracketAstNode | TextAstNode | undefined);
+    constructor(length: Length, kind: TokenKind, 
+    /**
+     * If this token is an opening bracket, this is the id of the opening bracket.
+     * If this token is a closing bracket, this is the id of the first opening bracket that is closed by this bracket.
+     * Otherwise, it is -1.
+     */
+    bracketId: OpeningBracketId, 
+    /**
+     * If this token is an opening bracket, this just contains `bracketId`.
+     * If this token is a closing bracket, this lists all opening bracket ids, that it closes.
+     * Otherwise, it is empty.
+     */
+    bracketIds: SmallImmutableSet<OpeningBracketId>, astNode: BracketAstNode | TextAstNode | undefined);
 }
 export interface ITokenizerSource {
     getValue(): string;

package/vscode/src/vs/editor/common/model/decorationProvider.d.ts

@@ -2,7 +2,20 @@ import { Event } from "../../../base/common/event.js";
 import { Range } from "../core/range.js";
 import { IModelDecoration } from "../model.js";
 export interface DecorationProvider {
+    /**
+     * Gets all the decorations in a range as an array. Only `startLineNumber` and `endLineNumber` from `range` are used for filtering.
+     * So for now it returns all the decorations on the same line as `range`.
+     * @param range The range to search in
+     * @param ownerId If set, it will ignore decorations belonging to other owners.
+     * @param filterOutValidation If set, it will ignore decorations specific to validation (i.e. warnings, errors).
+     * @return An array with the decorations
+     */
     getDecorationsInRange(range: Range, ownerId?: number, filterOutValidation?: boolean): IModelDecoration[];
+    /**
+     * Gets all the decorations as an array.
+     * @param ownerId If set, it will ignore decorations belonging to other owners.
+     * @param filterOutValidation If set, it will ignore decorations specific to validation (i.e. warnings, errors).
+     */
     getAllDecorations(ownerId?: number, filterOutValidation?: boolean, onlyMinimapDecorations?: boolean): IModelDecoration[];
     onDidChange: Event<void>;
 }

package/vscode/src/vs/editor/common/model/fixedArray.d.ts

@@ -1,3 +1,7 @@
+/**
+ * An array that avoids being sparse by always
+ * filling up unused indices with a default value.
+ */
 export declare class FixedArray<T> {
     private readonly _default;
     private _store;

package/vscode/src/vs/editor/common/model/indentationGuesser.d.ts

@@ -1,6 +1,15 @@
 import { ITextBuffer } from "../model.js";
+/**
+ * Result for a guessIndentation
+ */
 export interface IGuessedIndentation {
+    /**
+     * If indentation is based on spaces (`insertSpaces` = true), then what is the number of spaces that make an indent?
+     */
     tabSize: number;
+    /**
+     * Is indentation based on spaces?
+     */
     insertSpaces: boolean;
 }
 export declare function guessIndentation(source: ITextBuffer, defaultTabSize: number, defaultInsertSpaces: boolean): IGuessedIndentation;

package/vscode/src/vs/editor/common/model/intervalTree.d.ts

@@ -17,6 +17,9 @@ export declare enum NodeColor {
 export declare function getNodeColor(node: IntervalNode): NodeColor;
 export declare function setNodeStickiness(node: IntervalNode, stickiness: ActualTrackedRangeStickiness): void;
 export declare class IntervalNode {
+    /**
+     * contains binary encoded information for color, visited, isForValidation and stickiness.
+     */
     metadata: number;
     parent: IntervalNode;
     left: IntervalNode;
@@ -45,7 +48,13 @@ export declare class IntervalTree {
     constructor();
     intervalSearch(start: number, end: number, filterOwnerId: number, filterOutValidation: boolean, filterFontDecorations: boolean, cachedVersionId: number, onlyMarginDecorations: boolean): IntervalNode[];
     search(filterOwnerId: number, filterOutValidation: boolean, filterFontDecorations: boolean, cachedVersionId: number, onlyMarginDecorations: boolean): IntervalNode[];
+    /**
+     * Will not set `cachedAbsoluteStart` nor `cachedAbsoluteEnd` on the returned nodes!
+     */
     collectNodesFromOwner(ownerId: number): IntervalNode[];
+    /**
+     * Will not set `cachedAbsoluteStart` nor `cachedAbsoluteEnd` on the returned nodes!
+     */
     collectNodesPostOrder(): IntervalNode[];
     insert(node: IntervalNode): void;
     delete(node: IntervalNode): void;
@@ -54,6 +63,10 @@ export declare class IntervalTree {
     getAllInOrder(): IntervalNode[];
     private _normalizeDeltaIfNecessary;
 }
+/**
+ * This is a lot more complicated than strictly necessary to maintain the same behaviour
+ * as when decorations were implemented using two markers.
+ */
 export declare function nodeAcceptEdit(node: IntervalNode, start: number, end: number, textLength: number, forceMoveMarkers: boolean): void;
 export declare function recomputeMaxEnd(node: IntervalNode): void;
 export declare function intervalCompare(aStart: number, aEnd: number, bStart: number, bEnd: number): number;

package/vscode/src/vs/editor/common/model/mirrorTextModel.d.ts

@@ -2,10 +2,25 @@ import { URI } from "../../../base/common/uri.js";
 import { IModelContentChange } from "../textModelEvents.js";
 import { PrefixSumComputer } from "./prefixSumComputer.js";
 export interface IModelChangedEvent {
+    /**
+     * The actual changes.
+     */
     readonly changes: IModelContentChange[];
+    /**
+     * The (new) end-of-line character.
+     */
     readonly eol: string;
+    /**
+     * The new version id the model has transitioned to.
+     */
     readonly versionId: number;
+    /**
+     * Flag that indicates that this event was generated while undoing.
+     */
     readonly isUndoing: boolean;
+    /**
+     * Flag that indicates that this event was generated while redoing.
+     */
     readonly isRedoing: boolean;
 }
 export interface IMirrorTextModel {
@@ -24,6 +39,9 @@ export declare class MirrorTextModel implements IMirrorTextModel {
     getText(): string;
     onEvents(e: IModelChangedEvent): void;
     protected _ensureLineStarts(): void;
+    /**
+     * All changes to a line's text go through this method
+     */
     private _setLineText;
     private _acceptDeleteRange;
     private _acceptInsertText;

package/vscode/src/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeBase.d.ts

@@ -14,12 +14,27 @@ declare class LineStarts {
 export declare function createLineStartsFast(str: string, readonly?: boolean): Uint32Array | Uint16Array | number[];
 export declare function createLineStarts(r: number[], str: string): LineStarts;
 interface NodePosition {
+    /**
+     * Piece Index
+     */
     node: TreeNode;
+    /**
+     * remainder in current piece.
+    */
     remainder: number;
+    /**
+     * node start offset in document.
+     */
     nodeStartOffset: number;
 }
 interface BufferCursor {
+    /**
+     * Line number in current buffer
+     */
     line: number;
+    /**
+     * Column number in current buffer
+     */
     column: number;
 }
 export declare class Piece {
@@ -101,7 +116,21 @@ export declare class PieceTreeBase {
     iterate(node: TreeNode, callback: (node: TreeNode) => boolean): boolean;
     private getNodeContent;
     getPieceContent(piece: Piece): string;
+    /**
+     *      node              node
+     *     /  \              /  \
+     *    a   b    <----   a    b
+     *                         /
+     *                        z
+     */
     private rbInsertRight;
+    /**
+     *      node              node
+     *     /  \              /  \
+     *    a   b     ---->   a    b
+     *                       \
+     *                        z
+     */
     private rbInsertLeft;
     private getContentOfSubTree;
 }

package/vscode/src/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBuffer.d.ts

@@ -55,12 +55,19 @@ export declare class PieceTreeTextBuffer extends Disposable implements ITextBuff
     private _getEndOfLine;
     setEOL(newEOL: "\r\n" | "\n"): void;
     applyEdits(rawOperations: ValidAnnotatedEditOperation[], recordTrimAutoWhitespace: boolean, computeUndoEdits: boolean): ApplyEditsResult;
+    /**
+     * Transform operations such that they represent the same logic edit,
+     * but that they also do not cause OOM crashes.
+     */
     private _reduceOperations;
     _toSingleEditOperation(operations: IValidatedEditOperation[]): IValidatedEditOperation;
     private _doApplyEdits;
     findMatchesLineByLine(searchRange: Range, searchData: SearchData, captureMatches: boolean, limitResultCount: number): FindMatch[];
     getPieceTree(): PieceTreeBase;
     static _getInverseEditRange(range: Range, text: string): Range;
+    /**
+     * Assumes `operations` are validated and sorted ascending
+     */
     static _getInverseEditRanges(operations: IValidatedEditOperation[]): Range[];
     private static _sortOpsAscending;
     private static _sortOpsDescending;

package/vscode/src/vs/editor/common/model/prefixSumComputer.d.ts

@@ -1,6 +1,15 @@
 export declare class PrefixSumComputer {
+    /**
+     * values[i] is the value at index i
+     */
     private values;
+    /**
+     * prefixSum[i] = SUM(heights[j]), 0 <= j <= i
+     */
     private prefixSum;
+    /**
+     * prefixSum[i], 0 <= i <= prefixSumValidIndex can be trusted
+     */
     private readonly prefixSumValidIndex;
     constructor(values: Uint32Array);
     getCount(): number;
@@ -8,19 +17,44 @@ export declare class PrefixSumComputer {
     setValue(index: number, value: number): boolean;
     removeValues(startIndex: number, count: number): boolean;
     getTotalSum(): number;
+    /**
+     * Returns the sum of the first `index + 1` many items.
+     * @returns `SUM(0 <= j <= index, values[j])`.
+     */
     getPrefixSum(index: number): number;
     private _getPrefixSum;
     getIndexOf(sum: number): PrefixSumIndexOfResult;
 }
+/**
+ * {@link getIndexOf} has an amortized runtime complexity of O(1).
+ *
+ * ({@link PrefixSumComputer.getIndexOf} is just  O(log n))
+*/
 export declare class ConstantTimePrefixSumComputer {
     private _values;
     private _isValid;
     private _validEndIndex;
+    /**
+     * _prefixSum[i] = SUM(values[j]), 0 <= j <= i
+     */
     private _prefixSum;
+    /**
+     * _indexBySum[sum] = idx => _prefixSum[idx - 1] <= sum < _prefixSum[idx]
+    */
     private _indexBySum;
     constructor(values: number[]);
+    /**
+     * @returns SUM(0 <= j < values.length, values[j])
+     */
     getTotalSum(): number;
+    /**
+     * Returns the sum of the first `count` many items.
+     * @returns `SUM(0 <= j < count, values[j])`.
+     */
     getPrefixSum(count: number): number;
+    /**
+     * @returns `result`, such that `getPrefixSum(result.index) + result.remainder = sum`
+     */
     getIndexOf(sum: number): PrefixSumIndexOfResult;
     removeValues(start: number, deleteCount: number): void;
     insertValues(insertIndex: number, insertArr: number[]): void;

package/vscode/src/vs/editor/common/model/textModel.d.ts

@@ -82,6 +82,9 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     private __isDisposing;
     _isDisposing(): boolean;
     private _versionId;
+    /**
+     * Unlike, versionId, this can go down (via undo) or go to previous values (via redo)
+     */
     private _alternativeVersionId;
     private _initialUndoRedoSnapshot;
     private readonly _isTooLargeForSyncing;
@@ -91,6 +94,10 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     private _isUndoing;
     private _isRedoing;
     private _trimAutoWhitespaceLines;
+    /**
+     * Used to workaround broken clients that might attempt using a decoration id generated by a different model.
+     * It is not globally unique in order to limit it to one character.
+     */
     private readonly _instanceId;
     private _deltaDecorationCallCnt;
     private _lastDecorationId;
@@ -165,6 +172,10 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     getLineMaxColumn(lineNumber: number): number;
     getLineFirstNonWhitespaceColumn(lineNumber: number): number;
     getLineLastNonWhitespaceColumn(lineNumber: number): number;
+    /**
+     * Validates `range` is within buffer bounds, but allows it to sit in between surrogate pairs, etc.
+     * Will try to not allocate if possible.
+     */
     _validateRangeRelaxedNoAllocations(range: IRange): Range;
     private _isValidPosition;
     private _validatePosition;
@@ -194,7 +205,9 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     applyEdits(operations: readonly model.IIdentifiedSingleEditOperation[]): void;
     applyEdits(operations: readonly model.IIdentifiedSingleEditOperation[], computeUndoEdits: false): void;
     applyEdits(operations: readonly model.IIdentifiedSingleEditOperation[], computeUndoEdits: true): model.IValidEditOperation[];
+    /** @internal */
     applyEdits(operations: readonly model.IIdentifiedSingleEditOperation[], computeUndoEdits: false, reason: TextModelEditSource): void;
+    /** @internal */
     applyEdits(operations: readonly model.IIdentifiedSingleEditOperation[], computeUndoEdits: true, reason: TextModelEditSource): model.IValidEditOperation[];
     private _doApplyEdits;
     undo(): void | Promise<void>;
@@ -233,6 +246,10 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     getWordAtPosition(position: IPosition): IWordAtPosition | null;
     getWordUntilPosition(position: IPosition): IWordAtPosition;
     normalizePosition(position: Position, affinity: model.PositionAffinity): Position;
+    /**
+     * Gets the column at which indentation stops at a given line.
+     * @internal
+    */
     getLineIndentColumn(lineNumber: number): number;
     toString(): string;
 }

package/vscode/src/vs/editor/common/model/textModelSearch.d.ts

@@ -15,6 +15,10 @@ export declare function isMultilineRegexSource(searchString: string): boolean;
 export declare function createFindMatch(range: Range, rawMatches: RegExpExecArray, captureMatches: boolean): FindMatch;
 export declare class TextModelSearch {
     static findMatches(model: TextModel, searchParams: SearchParams, searchRange: Range, captureMatches: boolean, limitResultCount: number): FindMatch[];
+    /**
+     * Multiline search always executes on the lines concatenated with \n.
+     * We must therefore compensate for the count of \n in case the model is CRLF
+     */
     private static _getMultilineMatchRange;
     private static _doFindMatchesMultiline;
     private static _doFindMatchesLineByLine;