@vscode/chat-lib 0.0.1

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

@@ -0,0 +1,416 @@
+//!!! 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

@@ -0,0 +1,275 @@
+//!!! 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);
+	}
+}