yegaogao/amis-rpc-design
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
e0a9bc130b
amis-rpc-design/node_modules/monaco-editor/dev/vs/language/css/cssMode.js

2070 lines
74 KiB
JavaScript
Raw Normal View History

v1.0.0
2023-10-07 19:42:30 +08:00
"use strict";
/*!-----------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Version: 0.43.0(94c055bcbdd49f04a0fa15515e848542a79fb948)
* Released under the MIT license
* https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
*-----------------------------------------------------------------------------*/
define("vs/language/css/cssMode", ["require"],(require)=>{
var moduleExports = (() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined")
return require.apply(this, arguments);
throw new Error('Dynamic require of "' + x + '" is not supported');
});
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/fillers/monaco-editor-core-amd.ts
var require_monaco_editor_core_amd = __commonJS({
"src/fillers/monaco-editor-core-amd.ts"(exports, module) {
var api = __toESM(__require("vs/editor/editor.api"));
module.exports = api;
}
});
// src/language/css/cssMode.ts
var cssMode_exports = {};
__export(cssMode_exports, {
CompletionAdapter: () => CompletionAdapter,
DefinitionAdapter: () => DefinitionAdapter,
DiagnosticsAdapter: () => DiagnosticsAdapter,
DocumentColorAdapter: () => DocumentColorAdapter,
DocumentFormattingEditProvider: () => DocumentFormattingEditProvider,
DocumentHighlightAdapter: () => DocumentHighlightAdapter,
DocumentLinkAdapter: () => DocumentLinkAdapter,
DocumentRangeFormattingEditProvider: () => DocumentRangeFormattingEditProvider,
DocumentSymbolAdapter: () => DocumentSymbolAdapter,
FoldingRangeAdapter: () => FoldingRangeAdapter,
HoverAdapter: () => HoverAdapter,
ReferenceAdapter: () => ReferenceAdapter,
RenameAdapter: () => RenameAdapter,
SelectionRangeAdapter: () => SelectionRangeAdapter,
WorkerManager: () => WorkerManager,
fromPosition: () => fromPosition,
fromRange: () => fromRange,
setupMode: () => setupMode,
toRange: () => toRange,
toTextEdit: () => toTextEdit
});
// src/fillers/monaco-editor-core.ts
var monaco_editor_core_exports = {};
__reExport(monaco_editor_core_exports, __toESM(require_monaco_editor_core_amd()));
// src/language/css/workerManager.ts
var STOP_WHEN_IDLE_FOR = 2 * 60 * 1e3;
var WorkerManager = class {
_defaults;
_idleCheckInterval;
_lastUsedTime;
_configChangeListener;
_worker;
_client;
constructor(defaults) {
this._defaults = defaults;
this._worker = null;
this._client = null;
this._idleCheckInterval = window.setInterval(() => this._checkIfIdle(), 30 * 1e3);
this._lastUsedTime = 0;
this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker());
}
_stopWorker() {
if (this._worker) {
this._worker.dispose();
this._worker = null;
}
this._client = null;
}
dispose() {
clearInterval(this._idleCheckInterval);
this._configChangeListener.dispose();
this._stopWorker();
}
_checkIfIdle() {
if (!this._worker) {
return;
}
let timePassedSinceLastUsed = Date.now() - this._lastUsedTime;
if (timePassedSinceLastUsed > STOP_WHEN_IDLE_FOR) {
this._stopWorker();
}
}
_getClient() {
this._lastUsedTime = Date.now();
if (!this._client) {
this._worker = monaco_editor_core_exports.editor.createWebWorker({
moduleId: "vs/language/css/cssWorker",
label: this._defaults.languageId,
createData: {
options: this._defaults.options,
languageId: this._defaults.languageId
}
});
this._client = this._worker.getProxy();
}
return this._client;
}
getLanguageServiceWorker(...resources) {
let _client;
return this._getClient().then((client) => {
_client = client;
}).then((_) => {
if (this._worker) {
return this._worker.withSyncedResources(resources);
}
}).then((_) => _client);
}
};
// node_modules/vscode-languageserver-types/lib/esm/main.js
var integer;
(function(integer2) {
integer2.MIN_VALUE = -2147483648;
integer2.MAX_VALUE = 2147483647;
})(integer || (integer = {}));
var uinteger;
(function(uinteger2) {
uinteger2.MIN_VALUE = 0;
uinteger2.MAX_VALUE = 2147483647;
})(uinteger || (uinteger = {}));
var Position;
(function(Position3) {
function create(line, character) {
if (line === Number.MAX_VALUE) {
line = uinteger.MAX_VALUE;
}
if (character === Number.MAX_VALUE) {
character = uinteger.MAX_VALUE;
}
return { line, character };
}
Position3.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
}
Position3.is = is;
})(Position || (Position = {}));
var Range;
(function(Range3) {
function create(one, two, three, four) {
if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
return { start: Position.create(one, two), end: Position.create(three, four) };
} else if (Position.is(one) && Position.is(two)) {
return { start: one, end: two };
} else {
throw new Error("Range#create called with invalid arguments[" + one + ", " + two + ", " + three + ", " + four + "]");
}
}
Range3.create = create;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
}
Range3.is = is;
})(Range || (Range = {}));
var Location;
(function(Location2) {
function create(uri, range) {
return { uri, range };
}
Location2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
}
Location2.is = is;
})(Location || (Location = {}));
var LocationLink;
(function(LocationLink2) {
function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
return { targetUri, targetRange, targetSelectionRange, originSelectionRange };
}
LocationLink2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri) && (Range.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange)) && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
}
LocationLink2.is = is;
})(LocationLink || (LocationLink = {}));
var Color;
(function(Color2) {
function create(red, green, blue, alpha) {
return {
red,
green,
blue,
alpha
};
}
Color2.create = create;
function is(value) {
var candidate = value;
return Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
}
Color2.is = is;
})(Color || (Color = {}));
var ColorInformation;
(function(ColorInformation2) {
function create(range, color) {
return {
range,
color
};
}
ColorInformation2.create = create;
function is(value) {
var candidate = value;
return Range.is(candidate.range) && Color.is(candidate.color);
}
ColorInformation2.is = is;
})(ColorInformation || (ColorInformation = {}));
var ColorPresentation;
(function(ColorPresentation2) {
function create(label, textEdit, additionalTextEdits) {
return {
label,
textEdit,
additionalTextEdits
};
}
ColorPresentation2.create = create;
function is(value) {
var candidate = value;
return Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
}
ColorPresentation2.is = is;
})(ColorPresentation || (ColorPresentation = {}));
var FoldingRangeKind;
(function(FoldingRangeKind2) {
FoldingRangeKind2["Comment"] = "comment";
FoldingRangeKind2["Imports"] = "imports";
FoldingRangeKind2["Region"] = "region";
})(FoldingRangeKind || (FoldingRangeKind = {}));
var FoldingRange;
(function(FoldingRange2) {
function create(startLine, endLine, startCharacter, endCharacter, kind) {
var result = {
startLine,
endLine
};
if (Is.defined(startCharacter)) {
result.startCharacter = startCharacter;
}
if (Is.defined(endCharacter)) {
result.endCharacter = endCharacter;
}
if (Is.defined(kind)) {
result.kind = kind;
}
return result;
}
FoldingRange2.create = create;
function is(value) {
var candidate = value;
return Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
}
FoldingRange2.is = is;
})(FoldingRange || (FoldingRange = {}));
var DiagnosticRelatedInformation;
(function(DiagnosticRelatedInformation2) {
function create(location, message) {
return {
location,
message
};
}
DiagnosticRelatedInformation2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
}
DiagnosticRelatedInformation2.is = is;
})(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
var DiagnosticSeverity;
(function(DiagnosticSeverity2) {
DiagnosticSeverity2.Error = 1;
DiagnosticSeverity2.Warning = 2;
DiagnosticSeverity2.Information = 3;
DiagnosticSeverity2.Hint = 4;
})(DiagnosticSeverity || (DiagnosticSeverity = {}));
var DiagnosticTag;
(function(DiagnosticTag2) {
DiagnosticTag2.Unnecessary = 1;
DiagnosticTag2.Deprecated = 2;
})(DiagnosticTag || (DiagnosticTag = {}));
var CodeDescription;
(function(CodeDescription2) {
function is(value) {
var candidate = value;
return candidate !== void 0 && candidate !== null && Is.string(candidate.href);
}
CodeDescription2.is = is;
})(CodeDescription || (CodeDescription = {}));
var Diagnostic;
(function(Diagnostic2) {
function create(range, message, severity, code, source, relatedInformation) {
var result = { range, message };
if (Is.defined(severity)) {
result.severity = severity;
}
if (Is.defined(code)) {
result.code = code;
}
if (Is.defined(source)) {
result.source = source;
}
if (Is.defined(relatedInformation)) {
result.relatedInformation = relatedInformation;
}
return result;
}
Diagnostic2.create = create;
function is(value) {
var _a;
var candidate = value;
return Is.defined(candidate) && Range.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
}
Diagnostic2.is = is;
})(Diagnostic || (Diagnostic = {}));
var Command;
(function(Command2) {
function create(title, command) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
var result = { title, command };
if (Is.defined(args) && args.length > 0) {
result.arguments = args;
}
return result;
}
Command2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
}
Command2.is = is;
})(Command || (Command = {}));
var TextEdit;
(function(TextEdit2) {
function replace(range, newText) {
return { range, newText };
}
TextEdit2.replace = replace;
function insert(position, newText) {
return { range: { start: position, end: position }, newText };
}
TextEdit2.insert = insert;
function del(range) {
return { range, newText: "" };
}
TextEdit2.del = del;
function is(value) {
var candidate = value;
return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range.is(candidate.range);
}
TextEdit2.is = is;
})(TextEdit || (TextEdit = {}));
var ChangeAnnotation;
(function(ChangeAnnotation2) {
function create(label, needsConfirmation, description) {
var result = { label };
if (needsConfirmation !== void 0) {
result.needsConfirmation = needsConfirmation;
}
if (description !== void 0) {
result.description = description;
}
return result;
}
ChangeAnnotation2.create = create;
function is(value) {
var candidate = value;
return candidate !== void 0 && Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
}
ChangeAnnotation2.is = is;
})(ChangeAnnotation || (ChangeAnnotation = {}));
var ChangeAnnotationIdentifier;
(function(ChangeAnnotationIdentifier2) {
function is(value) {
var candidate = value;
return typeof candidate === "string";
}
ChangeAnnotationIdentifier2.is = is;
})(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
var AnnotatedTextEdit;
(function(AnnotatedTextEdit2) {
function replace(range, newText, annotation) {
return { range, newText, annotationId: annotation };
}
AnnotatedTextEdit2.replace = replace;
function insert(position, newText, annotation) {
return { range: { start: position, end: position }, newText, annotationId: annotation };
}
AnnotatedTextEdit2.insert = insert;
function del(range, annotation) {
return { range, newText: "", annotationId: annotation };
}
AnnotatedTextEdit2.del = del;
function is(value) {
var candidate = value;
return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
AnnotatedTextEdit2.is = is;
})(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
var TextDocumentEdit;
(function(TextDocumentEdit2) {
function create(textDocument, edits) {
return { textDocument, edits };
}
TextDocumentEdit2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
}
TextDocumentEdit2.is = is;
})(TextDocumentEdit || (TextDocumentEdit = {}));
var CreateFile;
(function(CreateFile2) {
function create(uri, options, annotation) {
var result = {
kind: "create",
uri
};
if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
result.options = options;
}
if (annotation !== void 0) {
result.annotationId = annotation;
}
return result;
}
CreateFile2.create = create;
function is(value) {
var candidate = value;
return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
CreateFile2.is = is;
})(CreateFile || (CreateFile = {}));
var RenameFile;
(function(RenameFile2) {
function create(oldUri, newUri, options, annotation) {
var result = {
kind: "rename",
oldUri,
newUri
};
if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
result.options = options;
}
if (annotation !== void 0) {
result.annotationId = annotation;
}
return result;
}
RenameFile2.create = create;
function is(value) {
var candidate = value;
return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
RenameFile2.is = is;
})(RenameFile || (RenameFile = {}));
var DeleteFile;
(function(DeleteFile2) {
function create(uri, options, annotation) {
var result = {
kind: "delete",
uri
};
if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
result.options = options;
}
if (annotation !== void 0) {
result.annotationId = annotation;
}
return result;
}
DeleteFile2.create = create;
function is(value) {
var candidate = value;
return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
}
DeleteFile2.is = is;
})(DeleteFile || (DeleteFile = {}));
var WorkspaceEdit;
(function(WorkspaceEdit2) {
function is(value) {
var candidate = value;
return candidate && (candidate.changes !== void 0 || candidate.documentChanges !== void 0) && (candidate.documentChanges === void 0 || candidate.documentChanges.every(function(change) {
if (Is.string(change.kind)) {
return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);
} else {
return TextDocumentEdit.is(change);
}
}));
}
WorkspaceEdit2.is = is;
})(WorkspaceEdit || (WorkspaceEdit = {}));
var TextEditChangeImpl = function() {
function TextEditChangeImpl2(edits, changeAnnotations) {
this.edits = edits;
this.changeAnnotations = changeAnnotations;
}
TextEditChangeImpl2.prototype.insert = function(position, newText, annotation) {
var edit;
var id;
if (annotation === void 0) {
edit = TextEdit.insert(position, newText);
} else if (ChangeAnnotationIdentifier.is(annotation)) {
id = annotation;
edit = AnnotatedTextEdit.insert(position, newText, annotation);
} else {
this.assertChangeAnnotations(this.changeAnnotations);
id = this.changeAnnotations.manage(annotation);
edit = AnnotatedTextEdit.insert(position, newText, id);
}
this.edits.push(edit);
if (id !== void 0) {
return id;
}
};
TextEditChangeImpl2.prototype.replace = function(range, newText, annotation) {
var edit;
var id;
if (annotation === void 0) {
edit = TextEdit.replace(range, newText);
} else if (ChangeAnnotationIdentifier.is(annotation)) {
id = annotation;
edit = AnnotatedTextEdit.replace(range, newText, annotation);
} else {
this.assertChangeAnnotations(this.changeAnnotations);
id = this.changeAnnotations.manage(annotation);
edit = AnnotatedTextEdit.replace(range, newText, id);
}
this.edits.push(edit);
if (id !== void 0) {
return id;
}
};
TextEditChangeImpl2.prototype.delete = function(range, annotation) {
var edit;
var id;
if (annotation === void 0) {
edit = TextEdit.del(range);
} else if (ChangeAnnotationIdentifier.is(annotation)) {
id = annotation;
edit = AnnotatedTextEdit.del(range, annotation);
} else {
this.assertChangeAnnotations(this.changeAnnotations);
id = this.changeAnnotations.manage(annotation);
edit = AnnotatedTextEdit.del(range, id);
}
this.edits.push(edit);
if (id !== void 0) {
return id;
}
};
TextEditChangeImpl2.prototype.add = function(edit) {
this.edits.push(edit);
};
TextEditChangeImpl2.prototype.all = function() {
return this.edits;
};
TextEditChangeImpl2.prototype.clear = function() {
this.edits.splice(0, this.edits.length);
};
TextEditChangeImpl2.prototype.assertChangeAnnotations = function(value) {
if (value === void 0) {
throw new Error("Text edit change is not configured to manage change annotations.");
}
};
return TextEditChangeImpl2;
}();
var ChangeAnnotations = function() {
function ChangeAnnotations2(annotations) {
this._annotations = annotations === void 0 ? /* @__PURE__ */ Object.create(null) : annotations;
this._counter = 0;
this._size = 0;
}
ChangeAnnotations2.prototype.all = function() {
return this._annotations;
};
Object.defineProperty(ChangeAnnotations2.prototype, "size", {
get: function() {
return this._size;
},
enumerable: false,
configurable: true
});
ChangeAnnotations2.prototype.manage = function(idOrAnnotation, annotation) {
var id;
if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
id = idOrAnnotation;
} else {
id = this.nextId();
annotation = idOrAnnotation;
}
if (this._annotations[id] !== void 0) {
throw new Error("Id " + id + " is already in use.");
}
if (annotation === void 0) {
throw new Error("No annotation provided for id " + id);
}
this._annotations[id] = annotation;
this._size++;
return id;
};
ChangeAnnotations2.prototype.nextId = function() {
this._counter++;
return this._counter.toString();
};
return ChangeAnnotations2;
}();
var WorkspaceChange = function() {
function WorkspaceChange2(workspaceEdit) {
var _this = this;
this._textEditChanges = /* @__PURE__ */ Object.create(null);
if (workspaceEdit !== void 0) {
this._workspaceEdit = workspaceEdit;
if (workspaceEdit.documentChanges) {
this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);
workspaceEdit.changeAnnotations = this._changeAnnotations.all();
workspaceEdit.documentChanges.forEach(function(change) {
if (TextDocumentEdit.is(change)) {
var textEditChange = new TextEditChangeImpl(change.edits, _this._changeAnnotations);
_this._textEditChanges[change.textDocument.uri] = textEditChange;
}
});
} else if (workspaceEdit.changes) {
Object.keys(workspaceEdit.changes).forEach(function(key) {
var textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);
_this._textEditChanges[key] = textEditChange;
});
}
} else {
this._workspaceEdit = {};
}
}
Object.defineProperty(WorkspaceChange2.prototype, "edit", {
get: function() {
this.initDocumentChanges();
if (this._changeAnnotations !== void 0) {
if (this._changeAnnotations.size === 0) {
this._workspaceEdit.changeAnnotations = void 0;
} else {
this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
}
}
return this._workspaceEdit;
},
enumerable: false,
configurable: true
});
WorkspaceChange2.prototype.getTextEditChange = function(key) {
if (OptionalVersionedTextDocumentIdentifier.is(key)) {
this.initDocumentChanges();
if (this._workspaceEdit.documentChanges === void 0) {
throw new Error("Workspace edit is not configured for document changes.");
}
var textDocument = { uri: key.uri, version: key.version };
var result = this._textEditChanges[textDocument.uri];
if (!result) {
var edits = [];
var textDocumentEdit = {
textDocument,
edits
};
this._workspaceEdit.documentChanges.push(textDocumentEdit);
result = new TextEditChangeImpl(edits, this._changeAnnotations);
this._textEditChanges[textDocument.uri] = result;
}
return result;
} else {
this.initChanges();
if (this._workspaceEdit.changes === void 0) {
throw new Error("Workspace edit is not configured for normal text edit changes.");
}
var result = this._textEditChanges[key];
if (!result) {
var edits = [];
this._workspaceEdit.changes[key] = edits;
result = new TextEditChangeImpl(edits);
this._textEditChanges[key] = result;
}
return result;
}
};
WorkspaceChange2.prototype.initDocumentChanges = function() {
if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
this._changeAnnotations = new ChangeAnnotations();
this._workspaceEdit.documentChanges = [];
this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
}
};
WorkspaceChange2.prototype.initChanges = function() {
if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
this._workspaceEdit.changes = /* @__PURE__ */ Object.create(null);
}
};
WorkspaceChange2.prototype.createFile = function(uri, optionsOrAnnotation, options) {
this.initDocumentChanges();
if (this._workspaceEdit.documentChanges === void 0) {
throw new Error("Workspace edit is not configured for document changes.");
}
var annotation;
if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
annotation = optionsOrAnnotation;
} else {
options = optionsOrAnnotation;
}
var operation;
var id;
if (annotation === void 0) {
operation = CreateFile.create(uri, options);
} else {
id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
operation = CreateFile.create(uri, options, id);
}
this._workspaceEdit.documentChanges.push(operation);
if (id !== void 0) {
return id;
}
};
WorkspaceChange2.prototype.renameFile = function(oldUri, newUri, optionsOrAnnotation, options) {
this.initDocumentChanges();
if (this._workspaceEdit.documentChanges === void 0) {
throw new Error("Workspace edit is not configured for document changes.");
}
var annotation;
if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
annotation = optionsOrAnnotation;
} else {
options = optionsOrAnnotation;
}
var operation;
var id;
if (annotation === void 0) {
operation = RenameFile.create(oldUri, newUri, options);
} else {
id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
operation = RenameFile.create(oldUri, newUri, options, id);
}
this._workspaceEdit.documentChanges.push(operation);
if (id !== void 0) {
return id;
}
};
WorkspaceChange2.prototype.deleteFile = function(uri, optionsOrAnnotation, options) {
this.initDocumentChanges();
if (this._workspaceEdit.documentChanges === void 0) {
throw new Error("Workspace edit is not configured for document changes.");
}
var annotation;
if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
annotation = optionsOrAnnotation;
} else {
options = optionsOrAnnotation;
}
var operation;
var id;
if (annotation === void 0) {
operation = DeleteFile.create(uri, options);
} else {
id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
operation = DeleteFile.create(uri, options, id);
}
this._workspaceEdit.documentChanges.push(operation);
if (id !== void 0) {
return id;
}
};
return WorkspaceChange2;
}();
var TextDocumentIdentifier;
(function(TextDocumentIdentifier2) {
function create(uri) {
return { uri };
}
TextDocumentIdentifier2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.uri);
}
TextDocumentIdentifier2.is = is;
})(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
var VersionedTextDocumentIdentifier;
(function(VersionedTextDocumentIdentifier2) {
function create(uri, version) {
return { uri, version };
}
VersionedTextDocumentIdentifier2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
}
VersionedTextDocumentIdentifier2.is = is;
})(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
var OptionalVersionedTextDocumentIdentifier;
(function(OptionalVersionedTextDocumentIdentifier2) {
function create(uri, version) {
return { uri, version };
}
OptionalVersionedTextDocumentIdentifier2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
}
OptionalVersionedTextDocumentIdentifier2.is = is;
})(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
var TextDocumentItem;
(function(TextDocumentItem2) {
function create(uri, languageId, version, text) {
return { uri, languageId, version, text };
}
TextDocumentItem2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
}
TextDocumentItem2.is = is;
})(TextDocumentItem || (TextDocumentItem = {}));
var MarkupKind;
(function(MarkupKind2) {
MarkupKind2.PlainText = "plaintext";
MarkupKind2.Markdown = "markdown";
})(MarkupKind || (MarkupKind = {}));
(function(MarkupKind2) {
function is(value) {
var candidate = value;
return candidate === MarkupKind2.PlainText || candidate === MarkupKind2.Markdown;
}
MarkupKind2.is = is;
})(MarkupKind || (MarkupKind = {}));
var MarkupContent;
(function(MarkupContent2) {
function is(value) {
var candidate = value;
return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
}
MarkupContent2.is = is;
})(MarkupContent || (MarkupContent = {}));
var CompletionItemKind;
(function(CompletionItemKind2) {
CompletionItemKind2.Text = 1;
CompletionItemKind2.Method = 2;
CompletionItemKind2.Function = 3;
CompletionItemKind2.Constructor = 4;
CompletionItemKind2.Field = 5;
CompletionItemKind2.Variable = 6;
CompletionItemKind2.Class = 7;
CompletionItemKind2.Interface = 8;
CompletionItemKind2.Module = 9;
CompletionItemKind2.Property = 10;
CompletionItemKind2.Unit = 11;
CompletionItemKind2.Value = 12;
CompletionItemKind2.Enum = 13;
CompletionItemKind2.Keyword = 14;
CompletionItemKind2.Snippet = 15;
CompletionItemKind2.Color = 16;
CompletionItemKind2.File = 17;
CompletionItemKind2.Reference = 18;
CompletionItemKind2.Folder = 19;
CompletionItemKind2.EnumMember = 20;
CompletionItemKind2.Constant = 21;
CompletionItemKind2.Struct = 22;
CompletionItemKind2.Event = 23;
CompletionItemKind2.Operator = 24;
CompletionItemKind2.TypeParameter = 25;
})(CompletionItemKind || (CompletionItemKind = {}));
var InsertTextFormat;
(function(InsertTextFormat2) {
InsertTextFormat2.PlainText = 1;
InsertTextFormat2.Snippet = 2;
})(InsertTextFormat || (InsertTextFormat = {}));
var CompletionItemTag;
(function(CompletionItemTag2) {
CompletionItemTag2.Deprecated = 1;
})(CompletionItemTag || (CompletionItemTag = {}));
var InsertReplaceEdit;
(function(InsertReplaceEdit2) {
function create(newText, insert, replace) {
return { newText, insert, replace };
}
InsertReplaceEdit2.create = create;
function is(value) {
var candidate = value;
return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);
}
InsertReplaceEdit2.is = is;
})(InsertReplaceEdit || (InsertReplaceEdit = {}));
var InsertTextMode;
(function(InsertTextMode2) {
InsertTextMode2.asIs = 1;
InsertTextMode2.adjustIndentation = 2;
})(InsertTextMode || (InsertTextMode = {}));
var CompletionItem;
(function(CompletionItem2) {
function create(label) {
return { label };
}
CompletionItem2.create = create;
})(CompletionItem || (CompletionItem = {}));
var CompletionList;
(function(CompletionList2) {
function create(items, isIncomplete) {
return { items: items ? items : [], isIncomplete: !!isIncomplete };
}
CompletionList2.create = create;
})(CompletionList || (CompletionList = {}));
var MarkedString;
(function(MarkedString2) {
function fromPlainText(plainText) {
return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
}
MarkedString2.fromPlainText = fromPlainText;
function is(value) {
var candidate = value;
return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
}
MarkedString2.is = is;
})(MarkedString || (MarkedString = {}));
var Hover;
(function(Hover2) {
function is(value) {
var candidate = value;
return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range.is(value.range));
}
Hover2.is = is;
})(Hover || (Hover = {}));
var ParameterInformation;
(function(ParameterInformation2) {
function create(label, documentation) {
return documentation ? { label, documentation } : { label };
}
ParameterInformation2.create = create;
})(ParameterInformation || (ParameterInformation = {}));
var SignatureInformation;
(function(SignatureInformation2) {
function create(label, documentation) {
var parameters = [];
for (var _i = 2; _i < arguments.length; _i++) {
parameters[_i - 2] = arguments[_i];
}
var result = { label };
if (Is.defined(documentation)) {
result.documentation = documentation;
}
if (Is.defined(parameters)) {
result.parameters = parameters;
} else {
result.parameters = [];
}
return result;
}
SignatureInformation2.create = create;
})(SignatureInformation || (SignatureInformation = {}));
var DocumentHighlightKind;
(function(DocumentHighlightKind2) {
DocumentHighlightKind2.Text = 1;
DocumentHighlightKind2.Read = 2;
DocumentHighlightKind2.Write = 3;
})(DocumentHighlightKind || (DocumentHighlightKind = {}));
var DocumentHighlight;
(function(DocumentHighlight2) {
function create(range, kind) {
var result = { range };
if (Is.number(kind)) {
result.kind = kind;
}
return result;
}
DocumentHighlight2.create = create;
})(DocumentHighlight || (DocumentHighlight = {}));
var SymbolKind;
(function(SymbolKind2) {
SymbolKind2.File = 1;
SymbolKind2.Module = 2;
SymbolKind2.Namespace = 3;
SymbolKind2.Package = 4;
SymbolKind2.Class = 5;
SymbolKind2.Method = 6;
SymbolKind2.Property = 7;
SymbolKind2.Field = 8;
SymbolKind2.Constructor = 9;
SymbolKind2.Enum = 10;
SymbolKind2.Interface = 11;
SymbolKind2.Function = 12;
SymbolKind2.Variable = 13;
SymbolKind2.Constant = 14;
SymbolKind2.String = 15;
SymbolKind2.Number = 16;
SymbolKind2.Boolean = 17;
SymbolKind2.Array = 18;
SymbolKind2.Object = 19;
SymbolKind2.Key = 20;
SymbolKind2.Null = 21;
SymbolKind2.EnumMember = 22;
SymbolKind2.Struct = 23;
SymbolKind2.Event = 24;
SymbolKind2.Operator = 25;
SymbolKind2.TypeParameter = 26;
})(SymbolKind || (SymbolKind = {}));
var SymbolTag;
(function(SymbolTag2) {
SymbolTag2.Deprecated = 1;
})(SymbolTag || (SymbolTag = {}));
var SymbolInformation;
(function(SymbolInformation2) {
function create(name, kind, range, uri, containerName) {
var result = {
name,
kind,
location: { uri, range }
};
if (containerName) {
result.containerName = containerName;
}
return result;
}
SymbolInformation2.create = create;
})(SymbolInformation || (SymbolInformation = {}));
var DocumentSymbol;
(function(DocumentSymbol2) {
function create(name, detail, kind, range, selectionRange, children) {
var result = {
name,
detail,
kind,
range,
selectionRange
};
if (children !== void 0) {
result.children = children;
}
return result;
}
DocumentSymbol2.create = create;
function is(value) {
var candidate = value;
return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range.is(candidate.range) && Range.is(candidate.selectionRange) && (candidate.detail === void 0 || Is.string(candidate.detail)) && (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children)) && (candidate.tags === void 0 || Array.isArray(candidate.tags));
}
DocumentSymbol2.is = is;
})(DocumentSymbol || (DocumentSymbol = {}));
var CodeActionKind;
(function(CodeActionKind2) {
CodeActionKind2.Empty = "";
CodeActionKind2.QuickFix = "quickfix";
CodeActionKind2.Refactor = "refactor";
CodeActionKind2.RefactorExtract = "refactor.extract";
CodeActionKind2.RefactorInline = "refactor.inline";
CodeActionKind2.RefactorRewrite = "refactor.rewrite";
CodeActionKind2.Source = "source";
CodeActionKind2.SourceOrganizeImports = "source.organizeImports";
CodeActionKind2.SourceFixAll = "source.fixAll";
})(CodeActionKind || (CodeActionKind = {}));
var CodeActionContext;
(function(CodeActionContext2) {
function create(diagnostics, only) {
var result = { diagnostics };
if (only !== void 0 && only !== null) {
result.only = only;
}
return result;
}
CodeActionContext2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string));
}
CodeActionContext2.is = is;
})(CodeActionContext || (CodeActionContext = {}));
var CodeAction;
(function(CodeAction2) {
function create(title, kindOrCommandOrEdit, kind) {
var result = { title };
var checkKind = true;
if (typeof kindOrCommandOrEdit === "string") {
checkKind = false;
result.kind = kindOrCommandOrEdit;
} else if (Command.is(kindOrCommandOrEdit)) {
result.command = kindOrCommandOrEdit;
} else {
result.edit = kindOrCommandOrEdit;
}
if (checkKind && kind !== void 0) {
result.kind = kind;
}
return result;
}
CodeAction2.create = create;
function is(value) {
var candidate = value;
return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit));
}
CodeAction2.is = is;
})(CodeAction || (CodeAction = {}));
var CodeLens;
(function(CodeLens2) {
function create(range, data) {
var result = { range };
if (Is.defined(data)) {
result.data = data;
}
return result;
}
CodeLens2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
}
CodeLens2.is = is;
})(CodeLens || (CodeLens = {}));
var FormattingOptions;
(function(FormattingOptions2) {
function create(tabSize, insertSpaces) {
return { tabSize, insertSpaces };
}
FormattingOptions2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
}
FormattingOptions2.is = is;
})(FormattingOptions || (FormattingOptions = {}));
var DocumentLink;
(function(DocumentLink2) {
function create(range, target, data) {
return { range, target, data };
}
DocumentLink2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
}
DocumentLink2.is = is;
})(DocumentLink || (DocumentLink = {}));
var SelectionRange;
(function(SelectionRange2) {
function create(range, parent) {
return { range, parent };
}
SelectionRange2.create = create;
function is(value) {
var candidate = value;
return candidate !== void 0 && Range.is(candidate.range) && (candidate.parent === void 0 || SelectionRange2.is(candidate.parent));
}
SelectionRange2.is = is;
})(SelectionRange || (SelectionRange = {}));
var TextDocument;
(function(TextDocument2) {
function create(uri, languageId, version, content) {
return new FullTextDocument(uri, languageId, version, content);
}
TextDocument2.create = create;
function is(value) {
var candidate = value;
return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
}
TextDocument2.is = is;
function applyEdits(document, edits) {
var text = document.getText();
var sortedEdits = mergeSort(edits, function(a, b) {
var 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 = text.length;
for (var i = sortedEdits.length - 1; i >= 0; i--) {
var e = sortedEdits[i];
var startOffset = document.offsetAt(e.range.start);
var endOffset = document.offsetAt(e.range.end);
if (endOffset <= lastModifiedOffset) {
text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
} else {
throw new Error("Overlapping edit");
}
lastModifiedOffset = startOffset;
}
return text;
}
TextDocument2.applyEdits = applyEdits;
function mergeSort(data, compare) {
if (data.length <= 1) {
return data;
}
var p = data.length / 2 | 0;
var left = data.slice(0, p);
var right = data.slice(p);
mergeSort(left, compare);
mergeSort(right, compare);
var leftIdx = 0;
var rightIdx = 0;
var i = 0;
while (leftIdx < left.length && rightIdx < right.length) {
var ret = compare(left[leftIdx], right[rightIdx]);
if (ret <= 0) {
data[i++] = left[leftIdx++];
} else {
data[i++] = right[rightIdx++];
}
}
while (leftIdx < left.length) {
data[i++] = left[leftIdx++];
}
while (rightIdx < right.length) {
data[i++] = right[rightIdx++];
}
return data;
}
})(TextDocument || (TextDocument = {}));
var FullTextDocument = function() {
function FullTextDocument2(uri, languageId, version, content) {
this._uri = uri;
this._languageId = languageId;
this._version = version;
this._content = content;
this._lineOffsets = void 0;
}
Object.defineProperty(FullTextDocument2.prototype, "uri", {
get: function() {
return this._uri;
},
enumerable: false,
configurable: true
});
Object.defineProperty(FullTextDocument2.prototype, "languageId", {
get: function() {
return this._languageId;
},
enumerable: false,
configurable: true
});
Object.defineProperty(FullTextDocument2.prototype, "version", {
get: function() {
return this._version;
},
enumerable: false,
configurable: true
});
FullTextDocument2.prototype.getText = function(range) {
if (range) {
var start = this.offsetAt(range.start);
var end = this.offsetAt(range.end);
return this._content.substring(start, end);
}
return this._content;
};
FullTextDocument2.prototype.update = function(event, version) {
this._content = event.text;
this._version = version;
this._lineOffsets = void 0;
};
FullTextDocument2.prototype.getLineOffsets = function() {
if (this._lineOffsets === void 0) {
var lineOffsets = [];
var text = this._content;
var isLineStart = true;
for (var i = 0; i < text.length; i++) {
if (isLineStart) {
lineOffsets.push(i);
isLineStart = false;
}
var ch = text.charAt(i);
isLineStart = ch === "\r" || ch === "\n";
if (ch === "\r" && i + 1 < text.length && text.charAt(i + 1) === "\n") {
i++;
}
}
if (isLineStart && text.length > 0) {
lineOffsets.push(text.length);
}
this._lineOffsets = lineOffsets;
}
return this._lineOffsets;
};
FullTextDocument2.prototype.positionAt = function(offset) {
offset = Math.max(Math.min(offset, this._content.length), 0);
var lineOffsets = this.getLineOffsets();
var low = 0, high = lineOffsets.length;
if (high === 0) {
return Position.create(0, offset);
}
while (low < high) {
var mid = Math.floor((low + high) / 2);
if (lineOffsets[mid] > offset) {
high = mid;
} else {
low = mid + 1;
}
}
var line = low - 1;
return Position.create(line, offset - lineOffsets[line]);
};
FullTextDocument2.prototype.offsetAt = function(position) {
var 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;
return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
};
Object.defineProperty(FullTextDocument2.prototype, "lineCount", {
get: function() {
return this.getLineOffsets().length;
},
enumerable: false,
configurable: true
});
return FullTextDocument2;
}();
var Is;
(function(Is2) {
var toString = Object.prototype.toString;
function defined(value) {
return typeof value !== "undefined";
}
Is2.defined = defined;
function undefined2(value) {
return typeof value === "undefined";
}
Is2.undefined = undefined2;
function boolean(value) {
return value === true || value === false;
}
Is2.boolean = boolean;
function string(value) {
return toString.call(value) === "[object String]";
}
Is2.string = string;
function number(value) {
return toString.call(value) === "[object Number]";
}
Is2.number = number;
function numberRange(value, min, max) {
return toString.call(value) === "[object Number]" && min <= value && value <= max;
}
Is2.numberRange = numberRange;
function integer2(value) {
return toString.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
}
Is2.integer = integer2;
function uinteger2(value) {
return toString.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
}
Is2.uinteger = uinteger2;
function func(value) {
return toString.call(value) === "[object Function]";
}
Is2.func = func;
function objectLiteral(value) {
return value !== null && typeof value === "object";
}
Is2.objectLiteral = objectLiteral;
function typedArray(value, check) {
return Array.isArray(value) && value.every(check);
}
Is2.typedArray = typedArray;
})(Is || (Is = {}));
// src/language/common/lspLanguageFeatures.ts
var DiagnosticsAdapter = class {
constructor(_languageId, _worker, configChangeEvent) {
this._languageId = _languageId;
this._worker = _worker;
const onModelAdd = (model) => {
let modeId = model.getLanguageId();
if (modeId !== this._languageId) {
return;
}
let handle;
this._listener[model.uri.toString()] = model.onDidChangeContent(() => {
window.clearTimeout(handle);
handle = window.setTimeout(() => this._doValidate(model.uri, modeId), 500);
});
this._doValidate(model.uri, modeId);
};
const onModelRemoved = (model) => {
monaco_editor_core_exports.editor.setModelMarkers(model, this._languageId, []);
let uriStr = model.uri.toString();
let listener = this._listener[uriStr];
if (listener) {
listener.dispose();
delete this._listener[uriStr];
}
};
this._disposables.push(monaco_editor_core_exports.editor.onDidCreateModel(onModelAdd));
this._disposables.push(monaco_editor_core_exports.editor.onWillDisposeModel(onModelRemoved));
this._disposables.push(monaco_editor_core_exports.editor.onDidChangeModelLanguage((event) => {
onModelRemoved(event.model);
onModelAdd(event.model);
}));
this._disposables.push(configChangeEvent((_) => {
monaco_editor_core_exports.editor.getModels().forEach((model) => {
if (model.getLanguageId() === this._languageId) {
onModelRemoved(model);
onModelAdd(model);
}
});
}));
this._disposables.push({
dispose: () => {
monaco_editor_core_exports.editor.getModels().forEach(onModelRemoved);
for (let key in this._listener) {
this._listener[key].dispose();
}
}
});
monaco_editor_core_exports.editor.getModels().forEach(onModelAdd);
}
_disposables = [];
_listener = /* @__PURE__ */ Object.create(null);
dispose() {
this._disposables.forEach((d) => d && d.dispose());
this._disposables.length = 0;
}
_doValidate(resource, languageId) {
this._worker(resource).then((worker) => {
return worker.doValidation(resource.toString());
}).then((diagnostics) => {
const markers = diagnostics.map((d) => toDiagnostics(resource, d));
let model = monaco_editor_core_exports.editor.getModel(resource);
if (model && model.getLanguageId() === languageId) {
monaco_editor_core_exports.editor.setModelMarkers(model, languageId, markers);
}
}).then(void 0, (err) => {
console.error(err);
});
}
};
function toSeverity(lsSeverity) {
switch (lsSeverity) {
case DiagnosticSeverity.Error:
return monaco_editor_core_exports.MarkerSeverity.Error;
case DiagnosticSeverity.Warning:
return monaco_editor_core_exports.MarkerSeverity.Warning;
case DiagnosticSeverity.Information:
return monaco_editor_core_exports.MarkerSeverity.Info;
case DiagnosticSeverity.Hint:
return monaco_editor_core_exports.MarkerSeverity.Hint;
default:
return monaco_editor_core_exports.MarkerSeverity.Info;
}
}
function toDiagnostics(resource, diag) {
let code = typeof diag.code === "number" ? String(diag.code) : diag.code;
return {
severity: toSeverity(diag.severity),
startLineNumber: diag.range.start.line + 1,
startColumn: diag.range.start.character + 1,
endLineNumber: diag.range.end.line + 1,
endColumn: diag.range.end.character + 1,
message: diag.message,
code,
source: diag.source
};
}
var CompletionAdapter = class {
constructor(_worker, _triggerCharacters) {
this._worker = _worker;
this._triggerCharacters = _triggerCharacters;
}
get triggerCharacters() {
return this._triggerCharacters;
}
provideCompletionItems(model, position, context, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => {
return worker.doComplete(resource.toString(), fromPosition(position));
}).then((info) => {
if (!info) {
return;
}
const wordInfo = model.getWordUntilPosition(position);
const wordRange = new monaco_editor_core_exports.Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
const items = info.items.map((entry) => {
const item = {
label: entry.label,
insertText: entry.insertText || entry.label,
sortText: entry.sortText,
filterText: entry.filterText,
documentation: entry.documentation,
detail: entry.detail,
command: toCommand(entry.command),
range: wordRange,
kind: toCompletionItemKind(entry.kind)
};
if (entry.textEdit) {
if (isInsertReplaceEdit(entry.textEdit)) {
item.range = {
insert: toRange(entry.textEdit.insert),
replace: toRange(entry.textEdit.replace)
};
} else {
item.range = toRange(entry.textEdit.range);
}
item.insertText = entry.textEdit.newText;
}
if (entry.additionalTextEdits) {
item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
}
if (entry.insertTextFormat === InsertTextFormat.Snippet) {
item.insertTextRules = monaco_editor_core_exports.languages.CompletionItemInsertTextRule.InsertAsSnippet;
}
return item;
});
return {
isIncomplete: info.isIncomplete,
suggestions: items
};
});
}
};
function fromPosition(position) {
if (!position) {
return void 0;
}
return { character: position.column - 1, line: position.lineNumber - 1 };
}
function fromRange(range) {
if (!range) {
return void 0;
}
return {
start: {
line: range.startLineNumber - 1,
character: range.startColumn - 1
},
end: { line: range.endLineNumber - 1, character: range.endColumn - 1 }
};
}
function toRange(range) {
if (!range) {
return void 0;
}
return new monaco_editor_core_exports.Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);
}
function isInsertReplaceEdit(edit) {
return typeof edit.insert !== "undefined" && typeof edit.replace !== "undefined";
}
function toCompletionItemKind(kind) {
const mItemKind = monaco_editor_core_exports.languages.CompletionItemKind;
switch (kind) {
case CompletionItemKind.Text:
return mItemKind.Text;
case CompletionItemKind.Method:
return mItemKind.Method;
case CompletionItemKind.Function:
return mItemKind.Function;
case CompletionItemKind.Constructor:
return mItemKind.Constructor;
case CompletionItemKind.Field:
return mItemKind.Field;
case CompletionItemKind.Variable:
return mItemKind.Variable;
case CompletionItemKind.Class:
return mItemKind.Class;
case CompletionItemKind.Interface:
return mItemKind.Interface;
case CompletionItemKind.Module:
return mItemKind.Module;
case CompletionItemKind.Property:
return mItemKind.Property;
case CompletionItemKind.Unit:
return mItemKind.Unit;
case CompletionItemKind.Value:
return mItemKind.Value;
case CompletionItemKind.Enum:
return mItemKind.Enum;
case CompletionItemKind.Keyword:
return mItemKind.Keyword;
case CompletionItemKind.Snippet:
return mItemKind.Snippet;
case CompletionItemKind.Color:
return mItemKind.Color;
case CompletionItemKind.File:
return mItemKind.File;
case CompletionItemKind.Reference:
return mItemKind.Reference;
}
return mItemKind.Property;
}
function toTextEdit(textEdit) {
if (!textEdit) {
return void 0;
}
return {
range: toRange(textEdit.range),
text: textEdit.newText
};
}
function toCommand(c) {
return c && c.command === "editor.action.triggerSuggest" ? { id: c.command, title: c.title, arguments: c.arguments } : void 0;
}
var HoverAdapter = class {
constructor(_worker) {
this._worker = _worker;
}
provideHover(model, position, token) {
let resource = model.uri;
return this._worker(resource).then((worker) => {
return worker.doHover(resource.toString(), fromPosition(position));
}).then((info) => {
if (!info) {
return;
}
return {
range: toRange(info.range),
contents: toMarkedStringArray(info.contents)
};
});
}
};
function isMarkupContent(thing) {
return thing && typeof thing === "object" && typeof thing.kind === "string";
}
function toMarkdownString(entry) {
if (typeof entry === "string") {
return {
value: entry
};
}
if (isMarkupContent(entry)) {
if (entry.kind === "plaintext") {
return {
value: entry.value.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&")
};
}
return {
value: entry.value
};
}
return { value: "```" + entry.language + "\n" + entry.value + "\n```\n" };
}
function toMarkedStringArray(contents) {
if (!contents) {
return void 0;
}
if (Array.isArray(contents)) {
return contents.map(toMarkdownString);
}
return [toMarkdownString(contents)];
}
var DocumentHighlightAdapter = class {
constructor(_worker) {
this._worker = _worker;
}
provideDocumentHighlights(model, position, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => worker.findDocumentHighlights(resource.toString(), fromPosition(position))).then((entries) => {
if (!entries) {
return;
}
return entries.map((entry) => {
return {
range: toRange(entry.range),
kind: toDocumentHighlightKind(entry.kind)
};
});
});
}
};
function toDocumentHighlightKind(kind) {
switch (kind) {
case DocumentHighlightKind.Read:
return monaco_editor_core_exports.languages.DocumentHighlightKind.Read;
case DocumentHighlightKind.Write:
return monaco_editor_core_exports.languages.DocumentHighlightKind.Write;
case DocumentHighlightKind.Text:
return monaco_editor_core_exports.languages.DocumentHighlightKind.Text;
}
return monaco_editor_core_exports.languages.DocumentHighlightKind.Text;
}
var DefinitionAdapter = class {
constructor(_worker) {
this._worker = _worker;
}
provideDefinition(model, position, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => {
return worker.findDefinition(resource.toString(), fromPosition(position));
}).then((definition) => {
if (!definition) {
return;
}
return [toLocation(definition)];
});
}
};
function toLocation(location) {
return {
uri: monaco_editor_core_exports.Uri.parse(location.uri),
range: toRange(location.range)
};
}
var ReferenceAdapter = class {
constructor(_worker) {
this._worker = _worker;
}
provideReferences(model, position, context, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => {
return worker.findReferences(resource.toString(), fromPosition(position));
}).then((entries) => {
if (!entries) {
return;
}
return entries.map(toLocation);
});
}
};
var RenameAdapter = class {
constructor(_worker) {
this._worker = _worker;
}
provideRenameEdits(model, position, newName, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => {
return worker.doRename(resource.toString(), fromPosition(position), newName);
}).then((edit) => {
return toWorkspaceEdit(edit);
});
}
};
function toWorkspaceEdit(edit) {
if (!edit || !edit.changes) {
return void 0;
}
let resourceEdits = [];
for (let uri in edit.changes) {
const _uri = monaco_editor_core_exports.Uri.parse(uri);
for (let e of edit.changes[uri]) {
resourceEdits.push({
resource: _uri,
versionId: void 0,
textEdit: {
range: toRange(e.range),
text: e.newText
}
});
}
}
return {
edits: resourceEdits
};
}
var DocumentSymbolAdapter = class {
constructor(_worker) {
this._worker = _worker;
}
provideDocumentSymbols(model, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => worker.findDocumentSymbols(resource.toString())).then((items) => {
if (!items) {
return;
}
return items.map((item) => ({
name: item.name,
detail: "",
containerName: item.containerName,
kind: toSymbolKind(item.kind),
range: toRange(item.location.range),
selectionRange: toRange(item.location.range),
tags: []
}));
});
}
};
function toSymbolKind(kind) {
let mKind = monaco_editor_core_exports.languages.SymbolKind;
switch (kind) {
case SymbolKind.File:
return mKind.Array;
case SymbolKind.Module:
return mKind.Module;
case SymbolKind.Namespace:
return mKind.Namespace;
case SymbolKind.Package:
return mKind.Package;
case SymbolKind.Class:
return mKind.Class;
case SymbolKind.Method:
return mKind.Method;
case SymbolKind.Property:
return mKind.Property;
case SymbolKind.Field:
return mKind.Field;
case SymbolKind.Constructor:
return mKind.Constructor;
case SymbolKind.Enum:
return mKind.Enum;
case SymbolKind.Interface:
return mKind.Interface;
case SymbolKind.Function:
return mKind.Function;
case SymbolKind.Variable:
return mKind.Variable;
case SymbolKind.Constant:
return mKind.Constant;
case SymbolKind.String:
return mKind.String;
case SymbolKind.Number:
return mKind.Number;
case SymbolKind.Boolean:
return mKind.Boolean;
case SymbolKind.Array:
return mKind.Array;
}
return mKind.Function;
}
var DocumentLinkAdapter = class {
constructor(_worker) {
this._worker = _worker;
}
provideLinks(model, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => worker.findDocumentLinks(resource.toString())).then((items) => {
if (!items) {
return;
}
return {
links: items.map((item) => ({
range: toRange(item.range),
url: item.target
}))
};
});
}
};
var DocumentFormattingEditProvider = class {
constructor(_worker) {
this._worker = _worker;
}
provideDocumentFormattingEdits(model, options, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => {
return worker.format(resource.toString(), null, fromFormattingOptions(options)).then((edits) => {
if (!edits || edits.length === 0) {
return;
}
return edits.map(toTextEdit);
});
});
}
};
var DocumentRangeFormattingEditProvider = class {
constructor(_worker) {
this._worker = _worker;
}
canFormatMultipleRanges = false;
provideDocumentRangeFormattingEdits(model, range, options, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => {
return worker.format(resource.toString(), fromRange(range), fromFormattingOptions(options)).then((edits) => {
if (!edits || edits.length === 0) {
return;
}
return edits.map(toTextEdit);
});
});
}
};
function fromFormattingOptions(options) {
return {
tabSize: options.tabSize,
insertSpaces: options.insertSpaces
};
}
var DocumentColorAdapter = class {
constructor(_worker) {
this._worker = _worker;
}
provideDocumentColors(model, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => worker.findDocumentColors(resource.toString())).then((infos) => {
if (!infos) {
return;
}
return infos.map((item) => ({
color: item.color,
range: toRange(item.range)
}));
});
}
provideColorPresentations(model, info, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range))).then((presentations) => {
if (!presentations) {
return;
}
return presentations.map((presentation) => {
let item = {
label: presentation.label
};
if (presentation.textEdit) {
item.textEdit = toTextEdit(presentation.textEdit);
}
if (presentation.additionalTextEdits) {
item.additionalTextEdits = presentation.additionalTextEdits.map(toTextEdit);
}
return item;
});
});
}
};
var FoldingRangeAdapter = class {
constructor(_worker) {
this._worker = _worker;
}
provideFoldingRanges(model, context, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => worker.getFoldingRanges(resource.toString(), context)).then((ranges) => {
if (!ranges) {
return;
}
return ranges.map((range) => {
const result = {
start: range.startLine + 1,
end: range.endLine + 1
};
if (typeof range.kind !== "undefined") {
result.kind = toFoldingRangeKind(range.kind);
}
return result;
});
});
}
};
function toFoldingRangeKind(kind) {
switch (kind) {
case FoldingRangeKind.Comment:
return monaco_editor_core_exports.languages.FoldingRangeKind.Comment;
case FoldingRangeKind.Imports:
return monaco_editor_core_exports.languages.FoldingRangeKind.Imports;
case FoldingRangeKind.Region:
return monaco_editor_core_exports.languages.FoldingRangeKind.Region;
}
return void 0;
}
var SelectionRangeAdapter = class {
constructor(_worker) {
this._worker = _worker;
}
provideSelectionRanges(model, positions, token) {
const resource = model.uri;
return this._worker(resource).then((worker) => worker.getSelectionRanges(resource.toString(), positions.map(fromPosition))).then((selectionRanges) => {
if (!selectionRanges) {
return;
}
return selectionRanges.map((selectionRange) => {
const result = [];
while (selectionRange) {
result.push({ range: toRange(selectionRange.range) });
selectionRange = selectionRange.parent;
}
return result;
});
});
}
};
// src/language/css/cssMode.ts
function setupMode(defaults) {
const disposables = [];
const providers = [];
const client = new WorkerManager(defaults);
disposables.push(client);
const worker = (...uris) => {
return client.getLanguageServiceWorker(...uris);
};
function registerProviders() {
const { languageId, modeConfiguration } = defaults;
disposeAll(providers);
if (modeConfiguration.completionItems) {
providers.push(monaco_editor_core_exports.languages.registerCompletionItemProvider(languageId, new CompletionAdapter(worker, ["/", "-", ":"])));
}
if (modeConfiguration.hovers) {
providers.push(monaco_editor_core_exports.languages.registerHoverProvider(languageId, new HoverAdapter(worker)));
}
if (modeConfiguration.documentHighlights) {
providers.push(monaco_editor_core_exports.languages.registerDocumentHighlightProvider(languageId, new DocumentHighlightAdapter(worker)));
}
if (modeConfiguration.definitions) {
providers.push(monaco_editor_core_exports.languages.registerDefinitionProvider(languageId, new DefinitionAdapter(worker)));
}
if (modeConfiguration.references) {
providers.push(monaco_editor_core_exports.languages.registerReferenceProvider(languageId, new ReferenceAdapter(worker)));
}
if (modeConfiguration.documentSymbols) {
providers.push(monaco_editor_core_exports.languages.registerDocumentSymbolProvider(languageId, new DocumentSymbolAdapter(worker)));
}
if (modeConfiguration.rename) {
providers.push(monaco_editor_core_exports.languages.registerRenameProvider(languageId, new RenameAdapter(worker)));
}
if (modeConfiguration.colors) {
providers.push(monaco_editor_core_exports.languages.registerColorProvider(languageId, new DocumentColorAdapter(worker)));
}
if (modeConfiguration.foldingRanges) {
providers.push(monaco_editor_core_exports.languages.registerFoldingRangeProvider(languageId, new FoldingRangeAdapter(worker)));
}
if (modeConfiguration.diagnostics) {
providers.push(new DiagnosticsAdapter(languageId, worker, defaults.onDidChange));
}
if (modeConfiguration.selectionRanges) {
providers.push(monaco_editor_core_exports.languages.registerSelectionRangeProvider(languageId, new SelectionRangeAdapter(worker)));
}
if (modeConfiguration.documentFormattingEdits) {
providers.push(monaco_editor_core_exports.languages.registerDocumentFormattingEditProvider(languageId, new DocumentFormattingEditProvider(worker)));
}
if (modeConfiguration.documentRangeFormattingEdits) {
providers.push(monaco_editor_core_exports.languages.registerDocumentRangeFormattingEditProvider(languageId, new DocumentRangeFormattingEditProvider(worker)));
}
}
registerProviders();
disposables.push(asDisposable(providers));
return asDisposable(disposables);
}
function asDisposable(disposables) {
return { dispose: () => disposeAll(disposables) };
}
function disposeAll(disposables) {
while (disposables.length) {
disposables.pop().dispose();
}
}
return __toCommonJS(cssMode_exports);
})();
return moduleExports;
});
Reference in New Issue Copy Permalink