@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/util/vs/editor/common/core/ranges/lineRange.ts

@@ -1,416 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { BugIndicatingError } from '../../../../base/common/errors';
-import { OffsetRange } from './offsetRange';
-import { Range } from '../range';
-import { findFirstIdxMonotonousOrArrLen, findLastIdxMonotonous, findLastMonotonous } from '../../../../base/common/arraysFind';
-import { Comparator, compareBy, numberComparator } from '../../../../base/common/arrays';
-
-/**
- * A range of lines (1-based).
- */
-export class LineRange {
-	public static ofLength(startLineNumber: number, length: number): LineRange {
-		return new LineRange(startLineNumber, startLineNumber + length);
-	}
-
-	public static fromRange(range: Range): LineRange {
-		return new LineRange(range.startLineNumber, range.endLineNumber);
-	}
-
-	public static fromRangeInclusive(range: Range): LineRange {
-		return new LineRange(range.startLineNumber, range.endLineNumber + 1);
-	}
-
-	public static readonly compareByStart: Comparator<LineRange> = compareBy(l => l.startLineNumber, numberComparator);
-
-	public static subtract(a: LineRange, b: LineRange | undefined): LineRange[] {
-		if (!b) {
-			return [a];
-		}
-		if (a.startLineNumber < b.startLineNumber && b.endLineNumberExclusive < a.endLineNumberExclusive) {
-			return [
-				new LineRange(a.startLineNumber, b.startLineNumber),
-				new LineRange(b.endLineNumberExclusive, a.endLineNumberExclusive)
-			];
-		} else if (b.startLineNumber <= a.startLineNumber && a.endLineNumberExclusive <= b.endLineNumberExclusive) {
-			return [];
-		} else if (b.endLineNumberExclusive < a.endLineNumberExclusive) {
-			return [new LineRange(Math.max(b.endLineNumberExclusive, a.startLineNumber), a.endLineNumberExclusive)];
-		} else {
-			return [new LineRange(a.startLineNumber, Math.min(b.startLineNumber, a.endLineNumberExclusive))];
-		}
-	}
-
-	/**
-	 * @param lineRanges An array of arrays of of sorted line ranges.
-	 */
-	public static joinMany(lineRanges: readonly (readonly LineRange[])[]): readonly LineRange[] {
-		if (lineRanges.length === 0) {
-			return [];
-		}
-		let result = new LineRangeSet(lineRanges[0].slice());
-		for (let i = 1; i < lineRanges.length; i++) {
-			result = result.getUnion(new LineRangeSet(lineRanges[i].slice()));
-		}
-		return result.ranges;
-	}
-
-	public static join(lineRanges: LineRange[]): LineRange {
-		if (lineRanges.length === 0) {
-			throw new BugIndicatingError('lineRanges cannot be empty');
-		}
-		let startLineNumber = lineRanges[0].startLineNumber;
-		let endLineNumberExclusive = lineRanges[0].endLineNumberExclusive;
-		for (let i = 1; i < lineRanges.length; i++) {
-			startLineNumber = Math.min(startLineNumber, lineRanges[i].startLineNumber);
-			endLineNumberExclusive = Math.max(endLineNumberExclusive, lineRanges[i].endLineNumberExclusive);
-		}
-		return new LineRange(startLineNumber, endLineNumberExclusive);
-	}
-
-	/**
-	 * @internal
-	 */
-	public static deserialize(lineRange: ISerializedLineRange): LineRange {
-		return new LineRange(lineRange[0], lineRange[1]);
-	}
-
-	/**
-	 * The start line number.
-	 */
-	public readonly startLineNumber: number;
-
-	/**
-	 * The end line number (exclusive).
-	 */
-	public readonly endLineNumberExclusive: number;
-
-	constructor(
-		startLineNumber: number,
-		endLineNumberExclusive: number,
-	) {
-		if (startLineNumber > endLineNumberExclusive) {
-			throw new BugIndicatingError(`startLineNumber ${startLineNumber} cannot be after endLineNumberExclusive ${endLineNumberExclusive}`);
-		}
-		this.startLineNumber = startLineNumber;
-		this.endLineNumberExclusive = endLineNumberExclusive;
-	}
-
-	/**
-	 * Indicates if this line range contains the given line number.
-	 */
-	public contains(lineNumber: number): boolean {
-		return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;
-	}
-
-	public containsRange(range: LineRange): boolean {
-		return this.startLineNumber <= range.startLineNumber && range.endLineNumberExclusive <= this.endLineNumberExclusive;
-	}
-
-	/**
-	 * Indicates if this line range is empty.
-	 */
-	get isEmpty(): boolean {
-		return this.startLineNumber === this.endLineNumberExclusive;
-	}
-
-	/**
-	 * Moves this line range by the given offset of line numbers.
-	 */
-	public delta(offset: number): LineRange {
-		return new LineRange(this.startLineNumber + offset, this.endLineNumberExclusive + offset);
-	}
-
-	public deltaLength(offset: number): LineRange {
-		return new LineRange(this.startLineNumber, this.endLineNumberExclusive + offset);
-	}
-
-	/**
-	 * The number of lines this line range spans.
-	 */
-	public get length(): number {
-		return this.endLineNumberExclusive - this.startLineNumber;
-	}
-
-	/**
-	 * Creates a line range that combines this and the given line range.
-	 */
-	public join(other: LineRange): LineRange {
-		return new LineRange(
-			Math.min(this.startLineNumber, other.startLineNumber),
-			Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive)
-		);
-	}
-
-	public toString(): string {
-		return `[${this.startLineNumber},${this.endLineNumberExclusive})`;
-	}
-
-	/**
-	 * The resulting range is empty if the ranges do not intersect, but touch.
-	 * If the ranges don't even touch, the result is undefined.
-	 */
-	public intersect(other: LineRange): LineRange | undefined {
-		const startLineNumber = Math.max(this.startLineNumber, other.startLineNumber);
-		const endLineNumberExclusive = Math.min(this.endLineNumberExclusive, other.endLineNumberExclusive);
-		if (startLineNumber <= endLineNumberExclusive) {
-			return new LineRange(startLineNumber, endLineNumberExclusive);
-		}
-		return undefined;
-	}
-
-	public intersectsStrict(other: LineRange): boolean {
-		return this.startLineNumber < other.endLineNumberExclusive && other.startLineNumber < this.endLineNumberExclusive;
-	}
-
-	public intersectsOrTouches(other: LineRange): boolean {
-		return this.startLineNumber <= other.endLineNumberExclusive && other.startLineNumber <= this.endLineNumberExclusive;
-	}
-
-	public equals(b: LineRange): boolean {
-		return this.startLineNumber === b.startLineNumber && this.endLineNumberExclusive === b.endLineNumberExclusive;
-	}
-
-	public toInclusiveRange(): Range | null {
-		if (this.isEmpty) {
-			return null;
-		}
-		return new Range(this.startLineNumber, 1, this.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER);
-	}
-
-	/**
-	 * @deprecated Using this function is discouraged because it might lead to bugs: The end position is not guaranteed to be a valid position!
-	*/
-	public toExclusiveRange(): Range {
-		return new Range(this.startLineNumber, 1, this.endLineNumberExclusive, 1);
-	}
-
-	public mapToLineArray<T>(f: (lineNumber: number) => T): T[] {
-		const result: T[] = [];
-		for (let lineNumber = this.startLineNumber; lineNumber < this.endLineNumberExclusive; lineNumber++) {
-			result.push(f(lineNumber));
-		}
-		return result;
-	}
-
-	public forEach(f: (lineNumber: number) => void): void {
-		for (let lineNumber = this.startLineNumber; lineNumber < this.endLineNumberExclusive; lineNumber++) {
-			f(lineNumber);
-		}
-	}
-
-	/**
-	 * @internal
-	 */
-	public serialize(): ISerializedLineRange {
-		return [this.startLineNumber, this.endLineNumberExclusive];
-	}
-
-	/**
-	 * Converts this 1-based line range to a 0-based offset range (subtracts 1!).
-	 * @internal
-	 */
-	public toOffsetRange(): OffsetRange {
-		return new OffsetRange(this.startLineNumber - 1, this.endLineNumberExclusive - 1);
-	}
-
-	public distanceToRange(other: LineRange): number {
-		if (this.endLineNumberExclusive <= other.startLineNumber) {
-			return other.startLineNumber - this.endLineNumberExclusive;
-		}
-		if (other.endLineNumberExclusive <= this.startLineNumber) {
-			return this.startLineNumber - other.endLineNumberExclusive;
-		}
-		return 0;
-	}
-
-	public distanceToLine(lineNumber: number): number {
-		if (this.contains(lineNumber)) {
-			return 0;
-		}
-		if (lineNumber < this.startLineNumber) {
-			return this.startLineNumber - lineNumber;
-		}
-		return lineNumber - this.endLineNumberExclusive;
-	}
-
-	public addMargin(marginTop: number, marginBottom: number): LineRange {
-		return new LineRange(
-			this.startLineNumber - marginTop,
-			this.endLineNumberExclusive + marginBottom
-		);
-	}
-}
-
-export type ISerializedLineRange = [startLineNumber: number, endLineNumberExclusive: number];
-
-
-export class LineRangeSet {
-	constructor(
-		/**
-		 * Sorted by start line number.
-		 * No two line ranges are touching or intersecting.
-		 */
-		private readonly _normalizedRanges: LineRange[] = []
-	) {
-	}
-
-	get ranges(): readonly LineRange[] {
-		return this._normalizedRanges;
-	}
-
-	addRange(range: LineRange): void {
-		if (range.length === 0) {
-			return;
-		}
-
-		// Idea: Find joinRange such that:
-		// replaceRange = _normalizedRanges.replaceRange(joinRange, range.joinAll(joinRange.map(idx => this._normalizedRanges[idx])))
-
-		// idx of first element that touches range or that is after range
-		const joinRangeStartIdx = findFirstIdxMonotonousOrArrLen(this._normalizedRanges, r => r.endLineNumberExclusive >= range.startLineNumber);
-		// idx of element after { last element that touches range or that is before range }
-		const joinRangeEndIdxExclusive = findLastIdxMonotonous(this._normalizedRanges, r => r.startLineNumber <= range.endLineNumberExclusive) + 1;
-
-		if (joinRangeStartIdx === joinRangeEndIdxExclusive) {
-			// If there is no element that touches range, then joinRangeStartIdx === joinRangeEndIdxExclusive and that value is the index of the element after range
-			this._normalizedRanges.splice(joinRangeStartIdx, 0, range);
-		} else if (joinRangeStartIdx === joinRangeEndIdxExclusive - 1) {
-			// Else, there is an element that touches range and in this case it is both the first and last element. Thus we can replace it
-			const joinRange = this._normalizedRanges[joinRangeStartIdx];
-			this._normalizedRanges[joinRangeStartIdx] = joinRange.join(range);
-		} else {
-			// First and last element are different - we need to replace the entire range
-			const joinRange = this._normalizedRanges[joinRangeStartIdx].join(this._normalizedRanges[joinRangeEndIdxExclusive - 1]).join(range);
-			this._normalizedRanges.splice(joinRangeStartIdx, joinRangeEndIdxExclusive - joinRangeStartIdx, joinRange);
-		}
-	}
-
-	contains(lineNumber: number): boolean {
-		const rangeThatStartsBeforeEnd = findLastMonotonous(this._normalizedRanges, r => r.startLineNumber <= lineNumber);
-		return !!rangeThatStartsBeforeEnd && rangeThatStartsBeforeEnd.endLineNumberExclusive > lineNumber;
-	}
-
-	intersects(range: LineRange): boolean {
-		const rangeThatStartsBeforeEnd = findLastMonotonous(this._normalizedRanges, r => r.startLineNumber < range.endLineNumberExclusive);
-		return !!rangeThatStartsBeforeEnd && rangeThatStartsBeforeEnd.endLineNumberExclusive > range.startLineNumber;
-	}
-
-	getUnion(other: LineRangeSet): LineRangeSet {
-		if (this._normalizedRanges.length === 0) {
-			return other;
-		}
-		if (other._normalizedRanges.length === 0) {
-			return this;
-		}
-
-		const result: LineRange[] = [];
-		let i1 = 0;
-		let i2 = 0;
-		let current: LineRange | null = null;
-		while (i1 < this._normalizedRanges.length || i2 < other._normalizedRanges.length) {
-			let next: LineRange | null = null;
-			if (i1 < this._normalizedRanges.length && i2 < other._normalizedRanges.length) {
-				const lineRange1 = this._normalizedRanges[i1];
-				const lineRange2 = other._normalizedRanges[i2];
-				if (lineRange1.startLineNumber < lineRange2.startLineNumber) {
-					next = lineRange1;
-					i1++;
-				} else {
-					next = lineRange2;
-					i2++;
-				}
-			} else if (i1 < this._normalizedRanges.length) {
-				next = this._normalizedRanges[i1];
-				i1++;
-			} else {
-				next = other._normalizedRanges[i2];
-				i2++;
-			}
-
-			if (current === null) {
-				current = next;
-			} else {
-				if (current.endLineNumberExclusive >= next.startLineNumber) {
-					// merge
-					current = new LineRange(current.startLineNumber, Math.max(current.endLineNumberExclusive, next.endLineNumberExclusive));
-				} else {
-					// push
-					result.push(current);
-					current = next;
-				}
-			}
-		}
-		if (current !== null) {
-			result.push(current);
-		}
-		return new LineRangeSet(result);
-	}
-
-	/**
-	 * Subtracts all ranges in this set from `range` and returns the result.
-	 */
-	subtractFrom(range: LineRange): LineRangeSet {
-		// idx of first element that touches range or that is after range
-		const joinRangeStartIdx = findFirstIdxMonotonousOrArrLen(this._normalizedRanges, r => r.endLineNumberExclusive >= range.startLineNumber);
-		// idx of element after { last element that touches range or that is before range }
-		const joinRangeEndIdxExclusive = findLastIdxMonotonous(this._normalizedRanges, r => r.startLineNumber <= range.endLineNumberExclusive) + 1;
-
-		if (joinRangeStartIdx === joinRangeEndIdxExclusive) {
-			return new LineRangeSet([range]);
-		}
-
-		const result: LineRange[] = [];
-		let startLineNumber = range.startLineNumber;
-		for (let i = joinRangeStartIdx; i < joinRangeEndIdxExclusive; i++) {
-			const r = this._normalizedRanges[i];
-			if (r.startLineNumber > startLineNumber) {
-				result.push(new LineRange(startLineNumber, r.startLineNumber));
-			}
-			startLineNumber = r.endLineNumberExclusive;
-		}
-		if (startLineNumber < range.endLineNumberExclusive) {
-			result.push(new LineRange(startLineNumber, range.endLineNumberExclusive));
-		}
-
-		return new LineRangeSet(result);
-	}
-
-	toString() {
-		return this._normalizedRanges.map(r => r.toString()).join(', ');
-	}
-
-	getIntersection(other: LineRangeSet): LineRangeSet {
-		const result: LineRange[] = [];
-
-		let i1 = 0;
-		let i2 = 0;
-		while (i1 < this._normalizedRanges.length && i2 < other._normalizedRanges.length) {
-			const r1 = this._normalizedRanges[i1];
-			const r2 = other._normalizedRanges[i2];
-
-			const i = r1.intersect(r2);
-			if (i && !i.isEmpty) {
-				result.push(i);
-			}
-
-			if (r1.endLineNumberExclusive < r2.endLineNumberExclusive) {
-				i1++;
-			} else {
-				i2++;
-			}
-		}
-
-		return new LineRangeSet(result);
-	}
-
-	getWithDelta(value: number): LineRangeSet {
-		return new LineRangeSet(this._normalizedRanges.map(r => r.delta(value)));
-	}
-}

package/src/_internal/util/vs/editor/common/core/ranges/offsetRange.ts

@@ -1,275 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { BugIndicatingError } from '../../../../base/common/errors';
-
-export interface IOffsetRange {
-	readonly start: number;
-	readonly endExclusive: number;
-}
-
-/**
- * A range of offsets (0-based).
-*/
-export class OffsetRange implements IOffsetRange {
-	public static fromTo(start: number, endExclusive: number): OffsetRange {
-		return new OffsetRange(start, endExclusive);
-	}
-
-	public static addRange(range: OffsetRange, sortedRanges: OffsetRange[]): void {
-		let i = 0;
-		while (i < sortedRanges.length && sortedRanges[i].endExclusive < range.start) {
-			i++;
-		}
-		let j = i;
-		while (j < sortedRanges.length && sortedRanges[j].start <= range.endExclusive) {
-			j++;
-		}
-		if (i === j) {
-			sortedRanges.splice(i, 0, range);
-		} else {
-			const start = Math.min(range.start, sortedRanges[i].start);
-			const end = Math.max(range.endExclusive, sortedRanges[j - 1].endExclusive);
-			sortedRanges.splice(i, j - i, new OffsetRange(start, end));
-		}
-	}
-
-	public static tryCreate(start: number, endExclusive: number): OffsetRange | undefined {
-		if (start > endExclusive) {
-			return undefined;
-		}
-		return new OffsetRange(start, endExclusive);
-	}
-
-	public static ofLength(length: number): OffsetRange {
-		return new OffsetRange(0, length);
-	}
-
-	public static ofStartAndLength(start: number, length: number): OffsetRange {
-		return new OffsetRange(start, start + length);
-	}
-
-	public static emptyAt(offset: number): OffsetRange {
-		return new OffsetRange(offset, offset);
-	}
-
-	constructor(public readonly start: number, public readonly endExclusive: number) {
-		if (start > endExclusive) {
-			throw new BugIndicatingError(`Invalid range: ${this.toString()}`);
-		}
-	}
-
-	get isEmpty(): boolean {
-		return this.start === this.endExclusive;
-	}
-
-	public delta(offset: number): OffsetRange {
-		return new OffsetRange(this.start + offset, this.endExclusive + offset);
-	}
-
-	public deltaStart(offset: number): OffsetRange {
-		return new OffsetRange(this.start + offset, this.endExclusive);
-	}
-
-	public deltaEnd(offset: number): OffsetRange {
-		return new OffsetRange(this.start, this.endExclusive + offset);
-	}
-
-	public get length(): number {
-		return this.endExclusive - this.start;
-	}
-
-	public toString() {
-		return `[${this.start}, ${this.endExclusive})`;
-	}
-
-	public equals(other: OffsetRange): boolean {
-		return this.start === other.start && this.endExclusive === other.endExclusive;
-	}
-
-	public containsRange(other: OffsetRange): boolean {
-		return this.start <= other.start && other.endExclusive <= this.endExclusive;
-	}
-
-	public contains(offset: number): boolean {
-		return this.start <= offset && offset < this.endExclusive;
-	}
-
-	/**
-	 * for all numbers n: range1.contains(n) or range2.contains(n) => range1.join(range2).contains(n)
-	 * The joined range is the smallest range that contains both ranges.
-	 */
-	public join(other: OffsetRange): OffsetRange {
-		return new OffsetRange(Math.min(this.start, other.start), Math.max(this.endExclusive, other.endExclusive));
-	}
-
-	/**
-	 * for all numbers n: range1.contains(n) and range2.contains(n) <=> range1.intersect(range2).contains(n)
-	 *
-	 * The resulting range is empty if the ranges do not intersect, but touch.
-	 * If the ranges don't even touch, the result is undefined.
-	 */
-	public intersect(other: OffsetRange): OffsetRange | undefined {
-		const start = Math.max(this.start, other.start);
-		const end = Math.min(this.endExclusive, other.endExclusive);
-		if (start <= end) {
-			return new OffsetRange(start, end);
-		}
-		return undefined;
-	}
-
-	public intersectionLength(range: OffsetRange): number {
-		const start = Math.max(this.start, range.start);
-		const end = Math.min(this.endExclusive, range.endExclusive);
-		return Math.max(0, end - start);
-	}
-
-	public intersects(other: OffsetRange): boolean {
-		const start = Math.max(this.start, other.start);
-		const end = Math.min(this.endExclusive, other.endExclusive);
-		return start < end;
-	}
-
-	public intersectsOrTouches(other: OffsetRange): boolean {
-		const start = Math.max(this.start, other.start);
-		const end = Math.min(this.endExclusive, other.endExclusive);
-		return start <= end;
-	}
-
-	public isBefore(other: OffsetRange): boolean {
-		return this.endExclusive <= other.start;
-	}
-
-	public isAfter(other: OffsetRange): boolean {
-		return this.start >= other.endExclusive;
-	}
-
-	public slice<T>(arr: readonly T[]): T[] {
-		return arr.slice(this.start, this.endExclusive);
-	}
-
-	public substring(str: string): string {
-		return str.substring(this.start, this.endExclusive);
-	}
-
-	/**
-	 * Returns the given value if it is contained in this instance, otherwise the closest value that is contained.
-	 * The range must not be empty.
-	 */
-	public clip(value: number): number {
-		if (this.isEmpty) {
-			throw new BugIndicatingError(`Invalid clipping range: ${this.toString()}`);
-		}
-		return Math.max(this.start, Math.min(this.endExclusive - 1, value));
-	}
-
-	/**
-	 * Returns `r := value + k * length` such that `r` is contained in this range.
-	 * The range must not be empty.
-	 *
-	 * E.g. `[5, 10).clipCyclic(10) === 5`, `[5, 10).clipCyclic(11) === 6` and `[5, 10).clipCyclic(4) === 9`.
-	 */
-	public clipCyclic(value: number): number {
-		if (this.isEmpty) {
-			throw new BugIndicatingError(`Invalid clipping range: ${this.toString()}`);
-		}
-		if (value < this.start) {
-			return this.endExclusive - ((this.start - value) % this.length);
-		}
-		if (value >= this.endExclusive) {
-			return this.start + ((value - this.start) % this.length);
-		}
-		return value;
-	}
-
-	public map<T>(f: (offset: number) => T): T[] {
-		const result: T[] = [];
-		for (let i = this.start; i < this.endExclusive; i++) {
-			result.push(f(i));
-		}
-		return result;
-	}
-
-	public forEach(f: (offset: number) => void): void {
-		for (let i = this.start; i < this.endExclusive; i++) {
-			f(i);
-		}
-	}
-
-	/**
-	 * this: [ 5, 10), range: [10, 15) => [5, 15)]
-	 * Throws if the ranges are not touching.
-	*/
-	public joinRightTouching(range: OffsetRange): OffsetRange {
-		if (this.endExclusive !== range.start) {
-			throw new BugIndicatingError(`Invalid join: ${this.toString()} and ${range.toString()}`);
-		}
-		return new OffsetRange(this.start, range.endExclusive);
-	}
-}
-
-export class OffsetRangeSet {
-	private readonly _sortedRanges: OffsetRange[] = [];
-
-	public get ranges(): OffsetRange[] {
-		return [...this._sortedRanges];
-	}
-
-	public addRange(range: OffsetRange): void {
-		let i = 0;
-		while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive < range.start) {
-			i++;
-		}
-		let j = i;
-		while (j < this._sortedRanges.length && this._sortedRanges[j].start <= range.endExclusive) {
-			j++;
-		}
-		if (i === j) {
-			this._sortedRanges.splice(i, 0, range);
-		} else {
-			const start = Math.min(range.start, this._sortedRanges[i].start);
-			const end = Math.max(range.endExclusive, this._sortedRanges[j - 1].endExclusive);
-			this._sortedRanges.splice(i, j - i, new OffsetRange(start, end));
-		}
-	}
-
-	public toString(): string {
-		return this._sortedRanges.map(r => r.toString()).join(', ');
-	}
-
-	/**
-	 * Returns of there is a value that is contained in this instance and the given range.
-	 */
-	public intersectsStrict(other: OffsetRange): boolean {
-		// TODO use binary search
-		let i = 0;
-		while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive <= other.start) {
-			i++;
-		}
-		return i < this._sortedRanges.length && this._sortedRanges[i].start < other.endExclusive;
-	}
-
-	public intersectWithRange(other: OffsetRange): OffsetRangeSet {
-		// TODO use binary search + slice
-		const result = new OffsetRangeSet();
-		for (const range of this._sortedRanges) {
-			const intersection = range.intersect(other);
-			if (intersection) {
-				result.addRange(intersection);
-			}
-		}
-		return result;
-	}
-
-	public intersectWithRangeLength(other: OffsetRange): number {
-		return this.intersectWithRange(other).length;
-	}
-
-	public get length(): number {
-		return this._sortedRanges.reduce((prev, cur) => prev + cur.length, 0);
-	}
-}