* Licensed under the MIT License. See License.txt in the project root for license information.
* ------------------------------------------------------------------------------------------ */
'use strict';
-var FullTextDocument = /** @class */ (function () {
- function FullTextDocument(uri, languageId, version, content) {
+class FullTextDocument {
+ constructor(uri, languageId, version, content) {
this._uri = uri;
this._languageId = languageId;
this._version = version;
this._content = content;
this._lineOffsets = undefined;
}
- Object.defineProperty(FullTextDocument.prototype, "uri", {
- get: function () {
- return this._uri;
- },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(FullTextDocument.prototype, "languageId", {
- get: function () {
- return this._languageId;
- },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(FullTextDocument.prototype, "version", {
- get: function () {
- return this._version;
- },
- enumerable: true,
- configurable: true
- });
- FullTextDocument.prototype.getText = function (range) {
+ get uri() {
+ return this._uri;
+ }
+ get languageId() {
+ return this._languageId;
+ }
+ get version() {
+ return this._version;
+ }
+ getText(range) {
if (range) {
- var start = this.offsetAt(range.start);
- var end = this.offsetAt(range.end);
+ const start = this.offsetAt(range.start);
+ const end = this.offsetAt(range.end);
return this._content.substring(start, end);
}
return this._content;
- };
- FullTextDocument.prototype.update = function (changes, version) {
- for (var _i = 0, changes_1 = changes; _i < changes_1.length; _i++) {
- var change = changes_1[_i];
+ }
+ update(changes, version) {
+ for (let change of changes) {
if (FullTextDocument.isIncremental(change)) {
// makes sure start is before end
- var range = getWellformedRange(change.range);
+ const range = getWellformedRange(change.range);
// update content
- var startOffset = this.offsetAt(range.start);
- var endOffset = this.offsetAt(range.end);
+ const startOffset = this.offsetAt(range.start);
+ const endOffset = this.offsetAt(range.end);
this._content = this._content.substring(0, startOffset) + change.text + this._content.substring(endOffset, this._content.length);
// update the offsets
- var startLine = Math.max(range.start.line, 0);
- var endLine = Math.max(range.end.line, 0);
- var lineOffsets = this._lineOffsets;
- var addedLineOffsets = computeLineOffsets(change.text, false, startOffset);
+ const startLine = Math.max(range.start.line, 0);
+ const endLine = Math.max(range.end.line, 0);
+ let lineOffsets = this._lineOffsets;
+ const addedLineOffsets = computeLineOffsets(change.text, false, startOffset);
if (endLine - startLine === addedLineOffsets.length) {
- for (var i = 0, len = addedLineOffsets.length; i < len; i++) {
+ for (let i = 0, len = addedLineOffsets.length; i < len; i++) {
lineOffsets[i + startLine + 1] = addedLineOffsets[i];
}
}
else {
if (addedLineOffsets.length < 10000) {
- lineOffsets.splice.apply(lineOffsets, [startLine + 1, endLine - startLine].concat(addedLineOffsets));
+ lineOffsets.splice(startLine + 1, endLine - startLine, ...addedLineOffsets);
}
else { // avoid too many arguments for splice
this._lineOffsets = lineOffsets = lineOffsets.slice(0, startLine + 1).concat(addedLineOffsets, lineOffsets.slice(endLine + 1));
}
}
- var diff = change.text.length - (endOffset - startOffset);
+ const diff = change.text.length - (endOffset - startOffset);
if (diff !== 0) {
- for (var i = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i < len; i++) {
+ for (let i = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i < len; i++) {
lineOffsets[i] = lineOffsets[i] + diff;
}
}
}
}
this._version = version;
- };
- FullTextDocument.prototype.getLineOffsets = function () {
+ }
+ getLineOffsets() {
if (this._lineOffsets === undefined) {
this._lineOffsets = computeLineOffsets(this._content, true);
}
return this._lineOffsets;
- };
- FullTextDocument.prototype.positionAt = function (offset) {
+ }
+ positionAt(offset) {
offset = Math.max(Math.min(offset, this._content.length), 0);
- var lineOffsets = this.getLineOffsets();
- var low = 0, high = lineOffsets.length;
+ let lineOffsets = this.getLineOffsets();
+ let low = 0, high = lineOffsets.length;
if (high === 0) {
return { line: 0, character: offset };
}
while (low < high) {
- var mid = Math.floor((low + high) / 2);
+ let mid = Math.floor((low + high) / 2);
if (lineOffsets[mid] > offset) {
high = mid;
}
}
// low is the least x for which the line offset is larger than the current offset
// or array.length if no line offset is larger than the current offset
- var line = low - 1;
- return { line: line, character: offset - lineOffsets[line] };
- };
- FullTextDocument.prototype.offsetAt = function (position) {
- var lineOffsets = this.getLineOffsets();
+ let line = low - 1;
+ return { line, character: offset - lineOffsets[line] };
+ }
+ offsetAt(position) {
+ let lineOffsets = this.getLineOffsets();
if (position.line >= lineOffsets.length) {
return this._content.length;
}
else if (position.line < 0) {
return 0;
}
- var lineOffset = lineOffsets[position.line];
- var nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;
+ let lineOffset = lineOffsets[position.line];
+ let nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;
return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
- };
- Object.defineProperty(FullTextDocument.prototype, "lineCount", {
- get: function () {
- return this.getLineOffsets().length;
- },
- enumerable: true,
- configurable: true
- });
- FullTextDocument.isIncremental = function (event) {
- var candidate = event;
+ }
+ get lineCount() {
+ return this.getLineOffsets().length;
+ }
+ static isIncremental(event) {
+ let candidate = event;
return candidate !== undefined && candidate !== null &&
typeof candidate.text === 'string' && candidate.range !== undefined &&
(candidate.rangeLength === undefined || typeof candidate.rangeLength === 'number');
- };
- FullTextDocument.isFull = function (event) {
- var candidate = event;
+ }
+ static isFull(event) {
+ let candidate = event;
return candidate !== undefined && candidate !== null &&
typeof candidate.text === 'string' && candidate.range === undefined && candidate.rangeLength === undefined;
- };
- return FullTextDocument;
-}());
+ }
+}
export var TextDocument;
(function (TextDocument) {
/**
}
TextDocument.create = create;
/**
- * Updates a TextDocument by modifing its content.
+ * Updates a TextDocument by modifying its content.
*
* @param document the document to update. Only documents created by TextDocument.create are valid inputs.
* @param changes the changes to apply to the document.
+ * @param version the changes version for the document.
* @returns The updated TextDocument. Note: That's the same document instance passed in as first parameter.
*
*/
}
TextDocument.update = update;
function applyEdits(document, edits) {
- var text = document.getText();
- var sortedEdits = mergeSort(edits.map(getWellformedEdit), function (a, b) {
- var diff = a.range.start.line - b.range.start.line;
+ let text = document.getText();
+ let sortedEdits = mergeSort(edits.map(getWellformedEdit), (a, b) => {
+ let diff = a.range.start.line - b.range.start.line;
if (diff === 0) {
return a.range.start.character - b.range.start.character;
}
return diff;
});
- var lastModifiedOffset = 0;
- var spans = [];
- for (var _i = 0, sortedEdits_1 = sortedEdits; _i < sortedEdits_1.length; _i++) {
- var e = sortedEdits_1[_i];
- var startOffset = document.offsetAt(e.range.start);
+ let lastModifiedOffset = 0;
+ const spans = [];
+ for (const e of sortedEdits) {
+ let startOffset = document.offsetAt(e.range.start);
if (startOffset < lastModifiedOffset) {
throw new Error('Overlapping edit');
}
// sorted
return data;
}
- var p = (data.length / 2) | 0;
- var left = data.slice(0, p);
- var right = data.slice(p);
+ const p = (data.length / 2) | 0;
+ const left = data.slice(0, p);
+ const right = data.slice(p);
mergeSort(left, compare);
mergeSort(right, compare);
- var leftIdx = 0;
- var rightIdx = 0;
- var i = 0;
+ let leftIdx = 0;
+ let rightIdx = 0;
+ let i = 0;
while (leftIdx < left.length && rightIdx < right.length) {
- var ret = compare(left[leftIdx], right[rightIdx]);
+ let ret = compare(left[leftIdx], right[rightIdx]);
if (ret <= 0) {
// smaller_equal -> take left to preserve order
data[i++] = left[leftIdx++];
}
return data;
}
-function computeLineOffsets(text, isAtLineStart, textOffset) {
- if (textOffset === void 0) { textOffset = 0; }
- var result = isAtLineStart ? [textOffset] : [];
- for (var i = 0; i < text.length; i++) {
- var ch = text.charCodeAt(i);
+function computeLineOffsets(text, isAtLineStart, textOffset = 0) {
+ const result = isAtLineStart ? [textOffset] : [];
+ for (let i = 0; i < text.length; i++) {
+ let ch = text.charCodeAt(i);
if (ch === 13 /* CarriageReturn */ || ch === 10 /* LineFeed */) {
if (ch === 13 /* CarriageReturn */ && i + 1 < text.length && text.charCodeAt(i + 1) === 10 /* LineFeed */) {
i++;
return result;
}
function getWellformedRange(range) {
- var start = range.start;
- var end = range.end;
+ const start = range.start;
+ const end = range.end;
if (start.line > end.line || (start.line === end.line && start.character > end.character)) {
return { start: end, end: start };
}
return range;
}
function getWellformedEdit(textEdit) {
- var range = getWellformedRange(textEdit.range);
+ const range = getWellformedRange(textEdit.range);
if (range !== textEdit.range) {
- return { newText: textEdit.newText, range: range };
+ return { newText: textEdit.newText, range };
}
return textEdit;
}
projects / dotfiles / .git / blobdiff