@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/platform/inlineEdits/common/dataTypes/permutation.ts

@@ -1,69 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { illegalArgument } from '../../../../util/vs/base/common/errors';
-
-/**
- * Represents a re-arrangement of items in an array.
- */
-export class Permutation {
-
-	/**
-	 * The index map describes the index in the original array.
-	 *
-	 * @example
-	 * ```typescript
-	 * const arr = [20, 10, 30];
-	 *
-	 * const arrSortedPermutation = new Permutation([1, 0, 2]);
-	 * // though consider using `Permutation.createSortPermutation(arr, (a, b) => a - b)` for sorting permutations
-	 * ```
-	 */
-	constructor(private readonly _indexMap: readonly number[]) { }
-
-	get arrayLength() {
-		return this._indexMap.length;
-	}
-
-	/**
-	 * Returns a permutation that sorts the given array according to the given compare function.
-	 */
-	public static createSortPermutation<T>(arr: readonly T[], compareFn: (a: T, b: T) => number): Permutation {
-		const sortIndices = Array.from(arr.keys()).sort((index1, index2) => compareFn(arr[index1], arr[index2]));
-		return new Permutation(sortIndices);
-	}
-
-	/**
-	 * Returns a new array with the elements of the given array re-arranged according to this permutation.
-	 */
-	apply<T>(arr: readonly T[]): T[] {
-		if (arr.length !== this.arrayLength) {
-			throw illegalArgument(`Permutation must be applied on an array of same length. Received length: ${arr.length}. Expected length: ${this.arrayLength}`);
-		}
-		return arr.map((_, index) => arr[this._indexMap[index]]);
-	}
-
-	/**
-	 * Given an index after permutation is, returns the index in the original array.
-	 */
-	mapIndexBack(indexAfterShuffling: number): number {
-		const originalArrIdx = this._indexMap.at(indexAfterShuffling);
-		if (originalArrIdx === undefined) {
-			throw illegalArgument(`Given index must be within original array length. Received: ${indexAfterShuffling}. Expected: 0 <= x < ${this.arrayLength}`);
-		}
-		return originalArrIdx;
-	}
-
-	/**
-	 * Returns a new permutation that undoes the re-arrangement of this permutation.
-	*/
-	inverse(): Permutation {
-		const inverseIndexMap = this._indexMap.slice();
-		for (let i = 0; i < this._indexMap.length; i++) {
-			inverseIndexMap[this._indexMap[i]] = i;
-		}
-		return new Permutation(inverseIndexMap);
-	}
-}

package/src/_internal/platform/inlineEdits/common/dataTypes/rootedLineEdit.ts

@@ -1,49 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { LineEdit, LineReplacement } from '../../../../util/vs/editor/common/core/edits/lineEdit';
-import { BaseStringEdit, StringEdit } from '../../../../util/vs/editor/common/core/edits/stringEdit';
-import { StringText } from '../../../../util/vs/editor/common/core/text/abstractText';
-import { ensureDependenciesAreSet } from '../../../../util/vs/editor/common/core/text/positionToOffset';
-import { RootedEdit } from './edit';
-
-ensureDependenciesAreSet();
-
-export class RootedLineEdit {
-	public static fromEdit<TEdit extends BaseStringEdit>(edit: RootedEdit<TEdit>): RootedLineEdit {
-		const lineEdit = LineEdit.fromEdit(edit.edit as BaseStringEdit as StringEdit, edit.base);
-		return new RootedLineEdit(edit.base, lineEdit);
-	}
-
-	constructor(
-		public readonly base: StringText,
-		public readonly edit: LineEdit,
-	) { }
-
-
-	public toString(): string {
-		return this.edit.humanReadablePatch(this.base.getLines());
-	}
-
-	public toEdit(): StringEdit {
-		return this.edit.toEdit(this.base);
-	}
-
-	public toRootedEdit(): RootedEdit {
-		return new RootedEdit(this.base, this.toEdit());
-	}
-
-	public getEditedState(): string[] {
-		const lines = this.base.getLines();
-		const newLines = this.edit.apply(lines);
-		return newLines;
-	}
-
-	public removeCommonSuffixPrefixLines(): RootedLineEdit {
-		const isNotEmptyEdit = (edit: LineReplacement) => !edit.lineRange.isEmpty || edit.newLines.length > 0;
-		const newEdit = this.edit.replacements.map(e => e.removeCommonSuffixPrefixLines(this.base)).filter(e => isNotEmptyEdit(e));
-		return new RootedLineEdit(this.base, new LineEdit(newEdit));
-	}
-}

package/src/_internal/platform/inlineEdits/common/dataTypes/textEditLength.ts

@@ -1,74 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { TextEdit } from '../../../../util/vs/editor/common/core/edits/textEdit';
-import { Range } from '../../../../util/vs/editor/common/core/range';
-import { TextLength } from '../../../../util/vs/editor/common/core/text/textLength';
-import { combineTextEditInfos } from './textEditLengthHelper/combineTextEditInfos';
-import { lengthsToRange, lengthToObj, toLength } from './textEditLengthHelper/length';
-import { TextEditInfo } from './textEditLengthHelper/textEditInfo';
-
-export class TextLengthEdit {
-	public static readonly empty = new TextLengthEdit([]);
-
-	public static fromTextEdit(textEdit: TextEdit): TextLengthEdit {
-		const edits = textEdit.replacements.map(e => new SingleTextEditLength(e.range, TextLength.ofText(e.text)));
-		return new TextLengthEdit(edits);
-	}
-
-	private static _fromTextEditInfo(info: TextEditInfo[]): TextLengthEdit {
-		const edits = info.map(e => {
-			const newLen = lengthToObj(e.newLength);
-			return new SingleTextEditLength(
-				lengthsToRange(e.startOffset, e.endOffset),
-				new TextLength(newLen.lineCount, newLen.columnCount),
-			);
-		});
-		return new TextLengthEdit(edits);
-	}
-
-	constructor(
-		public readonly edits: readonly SingleTextEditLength[],
-	) { }
-
-	private _toTextEditInfo(): TextEditInfo[] {
-		return this.edits.map(e => new TextEditInfo(
-			toLength(e.range.startLineNumber - 1, e.range.startColumn - 1),
-			toLength(e.range.endLineNumber - 1, e.range.endColumn - 1),
-			toLength(e.newLength.lineCount, e.newLength.columnCount),
-		));
-	}
-
-	public compose(other: TextLengthEdit): TextLengthEdit {
-		const self = this._toTextEditInfo();
-		const o = other._toTextEditInfo();
-
-		const result = combineTextEditInfos(self, o);
-		return TextLengthEdit._fromTextEditInfo(result);
-	}
-
-	/**
-	 * Returns the range of the edit, or undefined if the edit is empty.
-	 */
-	public getRange(): Range | undefined {
-		if (this.edits.length === 0) { return undefined; }
-		return Range.fromPositions(this.edits[0].range.getStartPosition(), this.edits.at(-1)!.range.getEndPosition());
-	}
-
-	public toString() {
-		return `[${this.edits.join(', ')}]`;
-	}
-}
-
-export class SingleTextEditLength {
-	constructor(
-		public readonly range: Range,
-		public readonly newLength: TextLength,
-	) { }
-
-	toString() {
-		return `{ range: ${this.range}, newLength: ${this.newLength} }`;
-	}
-}

package/src/_internal/platform/inlineEdits/common/dataTypes/textEditLengthHelper/combineTextEditInfos.ts

@@ -1,132 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { ArrayQueue } from '../../../../../util/vs/base/common/arrays.js';
-import { Length, lengthAdd, lengthDiffNonNegative, lengthEquals, lengthIsZero, lengthToObj, lengthZero, sumLengths } from './length.js';
-import { TextEditInfo } from './textEditInfo.js';
-
-export function combineTextEditInfos(textEditInfoFirst: TextEditInfo[], textEditInfoSecond: TextEditInfo[]): TextEditInfo[] {
-	if (textEditInfoFirst.length === 0) {
-		return textEditInfoSecond;
-	}
-	if (textEditInfoSecond.length === 0) {
-		return textEditInfoFirst;
-	}
-
-	// s0: State before any edits
-	const s0ToS1Map = new ArrayQueue(toLengthMapping(textEditInfoFirst));
-	// s1: State after first edit, but before second edit
-	const s1ToS2Map = toLengthMapping(textEditInfoSecond) as (LengthMapping | { lengthBefore: undefined; lengthAfter: undefined; modified: false })[];
-	s1ToS2Map.push({ modified: false, lengthBefore: undefined, lengthAfter: undefined }); // Copy everything from old to new
-	// s2: State after both edits
-
-	let curItem: LengthMapping | undefined = s0ToS1Map.dequeue();
-
-	/**
-	 * @param s1Length Use undefined for length "infinity"
-	 */
-	function nextS0ToS1MapWithS1LengthOf(s1Length: Length | undefined): LengthMapping[] {
-		if (s1Length === undefined) {
-			const arr = s0ToS1Map.takeWhile(v => true) || [];
-			if (curItem) {
-				arr.unshift(curItem);
-			}
-			return arr;
-		}
-
-		const result: LengthMapping[] = [];
-		while (curItem && !lengthIsZero(s1Length)) {
-			const [item, remainingItem] = curItem.splitAt(s1Length);
-			result.push(item);
-			s1Length = lengthDiffNonNegative(item.lengthAfter, s1Length);
-			curItem = remainingItem ?? s0ToS1Map.dequeue();
-		}
-		if (!lengthIsZero(s1Length)) {
-			result.push(new LengthMapping(false, s1Length, s1Length));
-		}
-		return result;
-	}
-
-	const result: TextEditInfo[] = [];
-
-	function pushEdit(startOffset: Length, endOffset: Length, newLength: Length): void {
-		if (result.length > 0 && lengthEquals(result[result.length - 1].endOffset, startOffset)) {
-			const lastResult = result[result.length - 1];
-			result[result.length - 1] = new TextEditInfo(lastResult.startOffset, endOffset, lengthAdd(lastResult.newLength, newLength));
-		} else {
-			result.push({ startOffset, endOffset, newLength });
-		}
-	}
-
-	let s0offset = lengthZero;
-	for (const s1ToS2 of s1ToS2Map) {
-		const s0ToS1Map = nextS0ToS1MapWithS1LengthOf(s1ToS2.lengthBefore);
-		if (s1ToS2.modified) {
-			const s0Length = sumLengths(s0ToS1Map, s => s.lengthBefore);
-			const s0EndOffset = lengthAdd(s0offset, s0Length);
-			pushEdit(s0offset, s0EndOffset, s1ToS2.lengthAfter);
-			s0offset = s0EndOffset;
-		} else {
-			for (const s1 of s0ToS1Map) {
-				const s0startOffset = s0offset;
-				s0offset = lengthAdd(s0offset, s1.lengthBefore);
-				if (s1.modified) {
-					pushEdit(s0startOffset, s0offset, s1.lengthAfter);
-				}
-			}
-		}
-	}
-
-	return result;
-}
-
-class LengthMapping {
-	constructor(
-		/**
-		 * If false, length before and length after equal.
-		 */
-		public readonly modified: boolean,
-		public readonly lengthBefore: Length,
-		public readonly lengthAfter: Length,
-	) {
-	}
-
-	splitAt(lengthAfter: Length): [LengthMapping, LengthMapping | undefined] {
-		const remainingLengthAfter = lengthDiffNonNegative(lengthAfter, this.lengthAfter);
-		if (lengthEquals(remainingLengthAfter, lengthZero)) {
-			return [this, undefined];
-		} else if (this.modified) {
-			return [
-				new LengthMapping(this.modified, this.lengthBefore, lengthAfter),
-				new LengthMapping(this.modified, lengthZero, remainingLengthAfter)
-			];
-		} else {
-			return [
-				new LengthMapping(this.modified, lengthAfter, lengthAfter),
-				new LengthMapping(this.modified, remainingLengthAfter, remainingLengthAfter)
-			];
-		}
-	}
-
-	toString(): string {
-		return `${this.modified ? 'M' : 'U'}:${lengthToObj(this.lengthBefore)} -> ${lengthToObj(this.lengthAfter)}`;
-	}
-}
-
-function toLengthMapping(textEditInfos: TextEditInfo[]): LengthMapping[] {
-	const result: LengthMapping[] = [];
-	let lastOffset = lengthZero;
-	for (const textEditInfo of textEditInfos) {
-		const spaceLength = lengthDiffNonNegative(lastOffset, textEditInfo.startOffset);
-		if (!lengthIsZero(spaceLength)) {
-			result.push(new LengthMapping(false, spaceLength, spaceLength));
-		}
-
-		const lengthBefore = lengthDiffNonNegative(textEditInfo.startOffset, textEditInfo.endOffset);
-		result.push(new LengthMapping(true, lengthBefore, textEditInfo.newLength));
-		lastOffset = textEditInfo.endOffset;
-	}
-	return result;
-}

package/src/_internal/platform/inlineEdits/common/dataTypes/textEditLengthHelper/length.ts

@@ -1,184 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { splitLines } from '../../../../../util/vs/base/common/strings';
-import { Position } from '../../../../../util/vs/editor/common/core/position';
-import { Range } from '../../../../../util/vs/editor/common/core/range';
-import { TextLength } from '../../../../../util/vs/editor/common/core/text/textLength';
-
-/**
- * The end must be greater than or equal to the start.
-*/
-export function lengthDiff(startLineCount: number, startColumnCount: number, endLineCount: number, endColumnCount: number): Length {
-	return (startLineCount !== endLineCount)
-		? toLength(endLineCount - startLineCount, endColumnCount)
-		: toLength(0, endColumnCount - startColumnCount);
-}
-
-/**
- * Represents a non-negative length in terms of line and column count.
- * Does not allocate.
-*/
-export type Length = { _brand: 'Length' };
-
-export const lengthZero = 0 as any as Length;
-
-export function lengthIsZero(length: Length): boolean {
-	return length as any as number === 0;
-}
-
-/*
- * We have 52 bits available in a JS number.
- * We use the upper 26 bits to store the line and the lower 26 bits to store the column.
- */
-///*
-const factor = 2 ** 26;
-/*/
-const factor = 1000000;
-// */
-
-export function toLength(lineCount: number, columnCount: number): Length {
-	// llllllllllllllllllllllllllcccccccccccccccccccccccccc (52 bits)
-	//       line count (26 bits)    column count (26 bits)
-
-	// If there is no overflow (all values/sums below 2^26 = 67108864),
-	// we have `toLength(lns1, cols1) + toLength(lns2, cols2) = toLength(lns1 + lns2, cols1 + cols2)`.
-
-	return (lineCount * factor + columnCount) as any as Length;
-}
-
-export function lengthToObj(length: Length): TextLength {
-	const l = length as any as number;
-	const lineCount = Math.floor(l / factor);
-	const columnCount = l - lineCount * factor;
-	return new TextLength(lineCount, columnCount);
-}
-
-export function lengthGetLineCount(length: Length): number {
-	return Math.floor(length as any as number / factor);
-}
-
-/**
- * Returns the amount of columns of the given length, assuming that it does not span any line.
-*/
-export function lengthGetColumnCountIfZeroLineCount(length: Length): number {
-	return length as any as number;
-}
-
-
-// [10 lines, 5 cols] + [ 0 lines, 3 cols] = [10 lines, 8 cols]
-// [10 lines, 5 cols] + [20 lines, 3 cols] = [30 lines, 3 cols]
-export function lengthAdd(length1: Length, length2: Length): Length;
-export function lengthAdd(l1: any, l2: any): Length {
-	let r = l1 + l2;
-	if (l2 >= factor) { r = r - (l1 % factor); }
-	return r;
-}
-
-export function sumLengths<T>(items: readonly T[], lengthFn: (item: T) => Length): Length {
-	return items.reduce((a, b) => lengthAdd(a, lengthFn(b)), lengthZero);
-}
-
-export function lengthEquals(length1: Length, length2: Length): boolean {
-	return length1 === length2;
-}
-
-/**
- * Returns a non negative length `result` such that `lengthAdd(length1, result) = length2`, or zero if such length does not exist.
- */
-export function lengthDiffNonNegative(length1: Length, length2: Length): Length {
-	const l1 = length1 as any as number;
-	const l2 = length2 as any as number;
-
-	const diff = l2 - l1;
-	if (diff <= 0) {
-		// line-count of length1 is higher than line-count of length2
-		// or they are equal and column-count of length1 is higher than column-count of length2
-		return lengthZero;
-	}
-
-	const lineCount1 = Math.floor(l1 / factor);
-	const lineCount2 = Math.floor(l2 / factor);
-
-	const colCount2 = l2 - lineCount2 * factor;
-
-	if (lineCount1 === lineCount2) {
-		const colCount1 = l1 - lineCount1 * factor;
-		return toLength(0, colCount2 - colCount1);
-	} else {
-		return toLength(lineCount2 - lineCount1, colCount2);
-	}
-}
-
-export function lengthLessThan(length1: Length, length2: Length): boolean {
-	// First, compare line counts, then column counts.
-	return (length1 as any as number) < (length2 as any as number);
-}
-
-export function lengthLessThanEqual(length1: Length, length2: Length): boolean {
-	return (length1 as any as number) <= (length2 as any as number);
-}
-
-export function lengthGreaterThanEqual(length1: Length, length2: Length): boolean {
-	return (length1 as any as number) >= (length2 as any as number);
-}
-
-export function lengthToPosition(length: Length): Position {
-	const l = length as any as number;
-	const lineCount = Math.floor(l / factor);
-	const colCount = l - lineCount * factor;
-	return new Position(lineCount + 1, colCount + 1);
-}
-
-export function positionToLength(position: Position): Length {
-	return toLength(position.lineNumber - 1, position.column - 1);
-}
-
-export function lengthsToRange(lengthStart: Length, lengthEnd: Length): Range {
-	const l = lengthStart as any as number;
-	const lineCount = Math.floor(l / factor);
-	const colCount = l - lineCount * factor;
-
-	const l2 = lengthEnd as any as number;
-	const lineCount2 = Math.floor(l2 / factor);
-	const colCount2 = l2 - lineCount2 * factor;
-
-	return new Range(lineCount + 1, colCount + 1, lineCount2 + 1, colCount2 + 1);
-}
-
-export function lengthOfRange(range: Range): TextLength {
-	if (range.startLineNumber === range.endLineNumber) {
-		return new TextLength(0, range.endColumn - range.startColumn);
-	} else {
-		return new TextLength(range.endLineNumber - range.startLineNumber, range.endColumn - 1);
-	}
-}
-
-export function lengthCompare(length1: Length, length2: Length): number {
-	const l1 = length1 as any as number;
-	const l2 = length2 as any as number;
-	return l1 - l2;
-}
-
-export function lengthOfString(str: string): Length {
-	const lines = splitLines(str);
-	return toLength(lines.length - 1, lines[lines.length - 1].length);
-}
-
-export function lengthOfStringObj(str: string): TextLength {
-	const lines = splitLines(str);
-	return new TextLength(lines.length - 1, lines[lines.length - 1].length);
-}
-
-/**
- * Computes a numeric hash of the given length.
-*/
-export function lengthHash(length: Length): number {
-	return length as any;
-}
-
-export function lengthMax(length1: Length, length2: Length): Length {
-	return length1 > length2 ? length1 : length2;
-}

package/src/_internal/platform/inlineEdits/common/dataTypes/textEditLengthHelper/textEditInfo.ts

@@ -1,32 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { Length, lengthToObj } from './length';
-
-export class TextEditInfo {
-	/*public static fromModelContentChanges(changes: IModelContentChange[]): TextEditInfo[] {
-		// Must be sorted in ascending order
-		const edits = changes.map(c => {
-			const range = Range.lift(c.range);
-			return new TextEditInfo(
-				positionToLength(range.getStartPosition()),
-				positionToLength(range.getEndPosition()),
-				lengthOfString(c.text)
-			);
-		}).reverse();
-		return edits;
-	}*/
-
-	constructor(
-		public readonly startOffset: Length,
-		public readonly endOffset: Length,
-		public readonly newLength: Length
-	) {
-	}
-
-	toString(): string {
-		return `[${lengthToObj(this.startOffset)}...${lengthToObj(this.endOffset)}) -> ${lengthToObj(this.newLength)}`;
-	}
-}

package/src/_internal/platform/inlineEdits/common/dataTypes/xtabPromptOptions.ts

@@ -1,89 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-export type RecentlyViewedDocumentsOptions = {
-	readonly nDocuments: number;
-	readonly maxTokens: number;
-	readonly includeViewedFiles: boolean;
-}
-
-export type LanguageContextLanguages = { [languageId: string]: boolean };
-
-export type LanguageContextOptions = {
-	readonly enabled: boolean;
-	readonly maxTokens: number;
-}
-
-export type DiffHistoryOptions = {
-	readonly nEntries: number;
-	readonly maxTokens: number;
-	readonly onlyForDocsInPrompt: boolean;
-	readonly useRelativePaths: boolean;
-}
-
-export type PagedClipping = { pageSize: number };
-
-export type CurrentFileOptions = {
-	readonly maxTokens: number;
-	readonly includeTags: boolean;
-	readonly prioritizeAboveCursor: boolean;
-}
-
-export type PromptOptions = {
-	readonly promptingStrategy: PromptingStrategy | undefined /* default */;
-	readonly currentFile: CurrentFileOptions;
-	readonly pagedClipping: PagedClipping;
-	readonly recentlyViewedDocuments: RecentlyViewedDocumentsOptions;
-	readonly languageContext: LanguageContextOptions;
-	readonly diffHistory: DiffHistoryOptions;
-}
-
-/**
- * Prompt strategies that tweak prompt in a way that's different from current prod prompting strategy.
- */
-export enum PromptingStrategy {
-	/**
-	 * Original Xtab unified model prompting strategy.
-	 */
-	UnifiedModel = 'xtabUnifiedModel',
-	Codexv21NesUnified = 'codexv21nesUnified',
-	Nes41Miniv3 = 'nes41miniv3',
-	SimplifiedSystemPrompt = 'simplifiedSystemPrompt',
-	Xtab275 = 'xtab275',
-}
-
-export const DEFAULT_OPTIONS: PromptOptions = {
-	promptingStrategy: undefined,
-	currentFile: {
-		maxTokens: 2000,
-		includeTags: true,
-		prioritizeAboveCursor: false,
-	},
-	pagedClipping: {
-		pageSize: 10,
-	},
-	recentlyViewedDocuments: {
-		nDocuments: 5,
-		maxTokens: 2000,
-		includeViewedFiles: false,
-	},
-	languageContext: {
-		enabled: false,
-		maxTokens: 2000,
-	},
-	diffHistory: {
-		nEntries: 25,
-		maxTokens: 1000,
-		onlyForDocsInPrompt: false,
-		useRelativePaths: false,
-	},
-};
-
-// TODO: consider a better per language setting/experiment approach
-export const LANGUAGE_CONTEXT_ENABLED_LANGUAGES: LanguageContextLanguages = {
-	'prompt': true,
-	'instructions': true,
-	'chatmode': true,
-};

package/src/_internal/platform/inlineEdits/common/debugRecorderBookmark.ts

@@ -1,10 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-export class DebugRecorderBookmark {
-	constructor(
-		public readonly timeMs: number,
-	) { }
-}