jsonMode.js2287 lines · main
| 1 | 'use strict' |
| 2 | /*!----------------------------------------------------------------------------- |
| 3 | * Copyright (c) Microsoft Corporation. All rights reserved. |
| 4 | * Version: 0.37.0(14a92401d7aff24ad84578a4c8b9a701ff533a84) |
| 5 | * Released under the MIT license |
| 6 | * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt |
| 7 | *-----------------------------------------------------------------------------*/ |
| 8 | define('vs/language/json/jsonMode', ['require', 'require'], (require) => { |
| 9 | var moduleExports = (() => { |
| 10 | var Tn = Object.create |
| 11 | var ie = Object.defineProperty |
| 12 | var bn = Object.getOwnPropertyDescriptor |
| 13 | var Cn = Object.getOwnPropertyNames |
| 14 | var wn = Object.getPrototypeOf, |
| 15 | In = Object.prototype.hasOwnProperty |
| 16 | var xn = ((e) => |
| 17 | typeof require != 'undefined' |
| 18 | ? require |
| 19 | : typeof Proxy != 'undefined' |
| 20 | ? new Proxy(e, { get: (t, i) => (typeof require != 'undefined' ? require : t)[i] }) |
| 21 | : e)(function (e) { |
| 22 | if (typeof require != 'undefined') return require.apply(this, arguments) |
| 23 | throw new Error('Dynamic require of "' + e + '" is not supported') |
| 24 | }) |
| 25 | var En = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), |
| 26 | _n = (e, t) => { |
| 27 | for (var i in t) ie(e, i, { get: t[i], enumerable: !0 }) |
| 28 | }, |
| 29 | te = (e, t, i, r) => { |
| 30 | if ((t && typeof t == 'object') || typeof t == 'function') |
| 31 | for (let n of Cn(t)) |
| 32 | !In.call(e, n) && |
| 33 | n !== i && |
| 34 | ie(e, n, { get: () => t[n], enumerable: !(r = bn(t, n)) || r.enumerable }) |
| 35 | return e |
| 36 | }, |
| 37 | Ee = (e, t, i) => (te(e, t, 'default'), i && te(i, t, 'default')), |
| 38 | _e = (e, t, i) => ( |
| 39 | (i = e != null ? Tn(wn(e)) : {}), |
| 40 | te(t || !e || !e.__esModule ? ie(i, 'default', { value: e, enumerable: !0 }) : i, e) |
| 41 | ), |
| 42 | Pn = (e) => te(ie({}, '__esModule', { value: !0 }), e) |
| 43 | var Se = En((gr, Pe) => { |
| 44 | var Sn = _e(xn('vs/editor/editor.api')) |
| 45 | Pe.exports = Sn |
| 46 | }) |
| 47 | var fr = {} |
| 48 | _n(fr, { |
| 49 | CompletionAdapter: () => X, |
| 50 | DefinitionAdapter: () => ke, |
| 51 | DiagnosticsAdapter: () => q, |
| 52 | DocumentColorAdapter: () => Z, |
| 53 | DocumentFormattingEditProvider: () => G, |
| 54 | DocumentHighlightAdapter: () => ye, |
| 55 | DocumentLinkAdapter: () => Ce, |
| 56 | DocumentRangeFormattingEditProvider: () => Q, |
| 57 | DocumentSymbolAdapter: () => $, |
| 58 | FoldingRangeAdapter: () => ee, |
| 59 | HoverAdapter: () => Y, |
| 60 | ReferenceAdapter: () => Te, |
| 61 | RenameAdapter: () => be, |
| 62 | SelectionRangeAdapter: () => ne, |
| 63 | WorkerManager: () => D, |
| 64 | fromPosition: () => L, |
| 65 | fromRange: () => we, |
| 66 | setupMode: () => cr, |
| 67 | toRange: () => C, |
| 68 | toTextEdit: () => j, |
| 69 | }) |
| 70 | var l = {} |
| 71 | Ee(l, _e(Se())) |
| 72 | var An = 2 * 60 * 1e3, |
| 73 | D = class { |
| 74 | _defaults |
| 75 | _idleCheckInterval |
| 76 | _lastUsedTime |
| 77 | _configChangeListener |
| 78 | _worker |
| 79 | _client |
| 80 | constructor(t) { |
| 81 | ;(this._defaults = t), |
| 82 | (this._worker = null), |
| 83 | (this._client = null), |
| 84 | (this._idleCheckInterval = window.setInterval(() => this._checkIfIdle(), 30 * 1e3)), |
| 85 | (this._lastUsedTime = 0), |
| 86 | (this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker())) |
| 87 | } |
| 88 | _stopWorker() { |
| 89 | this._worker && (this._worker.dispose(), (this._worker = null)), (this._client = null) |
| 90 | } |
| 91 | dispose() { |
| 92 | clearInterval(this._idleCheckInterval), |
| 93 | this._configChangeListener.dispose(), |
| 94 | this._stopWorker() |
| 95 | } |
| 96 | _checkIfIdle() { |
| 97 | if (!this._worker) return |
| 98 | Date.now() - this._lastUsedTime > An && this._stopWorker() |
| 99 | } |
| 100 | _getClient() { |
| 101 | return ( |
| 102 | (this._lastUsedTime = Date.now()), |
| 103 | this._client || |
| 104 | ((this._worker = l.editor.createWebWorker({ |
| 105 | moduleId: 'vs/language/json/jsonWorker', |
| 106 | label: this._defaults.languageId, |
| 107 | createData: { |
| 108 | languageSettings: this._defaults.diagnosticsOptions, |
| 109 | languageId: this._defaults.languageId, |
| 110 | enableSchemaRequest: this._defaults.diagnosticsOptions.enableSchemaRequest, |
| 111 | }, |
| 112 | })), |
| 113 | (this._client = this._worker.getProxy())), |
| 114 | this._client |
| 115 | ) |
| 116 | } |
| 117 | getLanguageServiceWorker(...t) { |
| 118 | let i |
| 119 | return this._getClient() |
| 120 | .then((r) => { |
| 121 | i = r |
| 122 | }) |
| 123 | .then((r) => { |
| 124 | if (this._worker) return this._worker.withSyncedResources(t) |
| 125 | }) |
| 126 | .then((r) => i) |
| 127 | } |
| 128 | } |
| 129 | var Ae |
| 130 | ;(function (e) { |
| 131 | ;(e.MIN_VALUE = -2147483648), (e.MAX_VALUE = 2147483647) |
| 132 | })(Ae || (Ae = {})) |
| 133 | var oe |
| 134 | ;(function (e) { |
| 135 | ;(e.MIN_VALUE = 0), (e.MAX_VALUE = 2147483647) |
| 136 | })(oe || (oe = {})) |
| 137 | var _ |
| 138 | ;(function (e) { |
| 139 | function t(r, n) { |
| 140 | return ( |
| 141 | r === Number.MAX_VALUE && (r = oe.MAX_VALUE), |
| 142 | n === Number.MAX_VALUE && (n = oe.MAX_VALUE), |
| 143 | { line: r, character: n } |
| 144 | ) |
| 145 | } |
| 146 | e.create = t |
| 147 | function i(r) { |
| 148 | var n = r |
| 149 | return s.objectLiteral(n) && s.uinteger(n.line) && s.uinteger(n.character) |
| 150 | } |
| 151 | e.is = i |
| 152 | })(_ || (_ = {})) |
| 153 | var y |
| 154 | ;(function (e) { |
| 155 | function t(r, n, a, o) { |
| 156 | if (s.uinteger(r) && s.uinteger(n) && s.uinteger(a) && s.uinteger(o)) |
| 157 | return { start: _.create(r, n), end: _.create(a, o) } |
| 158 | if (_.is(r) && _.is(n)) return { start: r, end: n } |
| 159 | throw new Error( |
| 160 | 'Range#create called with invalid arguments[' + r + ', ' + n + ', ' + a + ', ' + o + ']' |
| 161 | ) |
| 162 | } |
| 163 | e.create = t |
| 164 | function i(r) { |
| 165 | var n = r |
| 166 | return s.objectLiteral(n) && _.is(n.start) && _.is(n.end) |
| 167 | } |
| 168 | e.is = i |
| 169 | })(y || (y = {})) |
| 170 | var ge |
| 171 | ;(function (e) { |
| 172 | function t(r, n) { |
| 173 | return { uri: r, range: n } |
| 174 | } |
| 175 | e.create = t |
| 176 | function i(r) { |
| 177 | var n = r |
| 178 | return s.defined(n) && y.is(n.range) && (s.string(n.uri) || s.undefined(n.uri)) |
| 179 | } |
| 180 | e.is = i |
| 181 | })(ge || (ge = {})) |
| 182 | var Le |
| 183 | ;(function (e) { |
| 184 | function t(r, n, a, o) { |
| 185 | return { targetUri: r, targetRange: n, targetSelectionRange: a, originSelectionRange: o } |
| 186 | } |
| 187 | e.create = t |
| 188 | function i(r) { |
| 189 | var n = r |
| 190 | return ( |
| 191 | s.defined(n) && |
| 192 | y.is(n.targetRange) && |
| 193 | s.string(n.targetUri) && |
| 194 | (y.is(n.targetSelectionRange) || s.undefined(n.targetSelectionRange)) && |
| 195 | (y.is(n.originSelectionRange) || s.undefined(n.originSelectionRange)) |
| 196 | ) |
| 197 | } |
| 198 | e.is = i |
| 199 | })(Le || (Le = {})) |
| 200 | var pe |
| 201 | ;(function (e) { |
| 202 | function t(r, n, a, o) { |
| 203 | return { red: r, green: n, blue: a, alpha: o } |
| 204 | } |
| 205 | e.create = t |
| 206 | function i(r) { |
| 207 | var n = r |
| 208 | return ( |
| 209 | s.numberRange(n.red, 0, 1) && |
| 210 | s.numberRange(n.green, 0, 1) && |
| 211 | s.numberRange(n.blue, 0, 1) && |
| 212 | s.numberRange(n.alpha, 0, 1) |
| 213 | ) |
| 214 | } |
| 215 | e.is = i |
| 216 | })(pe || (pe = {})) |
| 217 | var Oe |
| 218 | ;(function (e) { |
| 219 | function t(r, n) { |
| 220 | return { range: r, color: n } |
| 221 | } |
| 222 | e.create = t |
| 223 | function i(r) { |
| 224 | var n = r |
| 225 | return y.is(n.range) && pe.is(n.color) |
| 226 | } |
| 227 | e.is = i |
| 228 | })(Oe || (Oe = {})) |
| 229 | var We |
| 230 | ;(function (e) { |
| 231 | function t(r, n, a) { |
| 232 | return { label: r, textEdit: n, additionalTextEdits: a } |
| 233 | } |
| 234 | e.create = t |
| 235 | function i(r) { |
| 236 | var n = r |
| 237 | return ( |
| 238 | s.string(n.label) && |
| 239 | (s.undefined(n.textEdit) || A.is(n)) && |
| 240 | (s.undefined(n.additionalTextEdits) || s.typedArray(n.additionalTextEdits, A.is)) |
| 241 | ) |
| 242 | } |
| 243 | e.is = i |
| 244 | })(We || (We = {})) |
| 245 | var M |
| 246 | ;(function (e) { |
| 247 | ;(e.Comment = 'comment'), (e.Imports = 'imports'), (e.Region = 'region') |
| 248 | })(M || (M = {})) |
| 249 | var Re |
| 250 | ;(function (e) { |
| 251 | function t(r, n, a, o, u) { |
| 252 | var c = { startLine: r, endLine: n } |
| 253 | return ( |
| 254 | s.defined(a) && (c.startCharacter = a), |
| 255 | s.defined(o) && (c.endCharacter = o), |
| 256 | s.defined(u) && (c.kind = u), |
| 257 | c |
| 258 | ) |
| 259 | } |
| 260 | e.create = t |
| 261 | function i(r) { |
| 262 | var n = r |
| 263 | return ( |
| 264 | s.uinteger(n.startLine) && |
| 265 | s.uinteger(n.startLine) && |
| 266 | (s.undefined(n.startCharacter) || s.uinteger(n.startCharacter)) && |
| 267 | (s.undefined(n.endCharacter) || s.uinteger(n.endCharacter)) && |
| 268 | (s.undefined(n.kind) || s.string(n.kind)) |
| 269 | ) |
| 270 | } |
| 271 | e.is = i |
| 272 | })(Re || (Re = {})) |
| 273 | var he |
| 274 | ;(function (e) { |
| 275 | function t(r, n) { |
| 276 | return { location: r, message: n } |
| 277 | } |
| 278 | e.create = t |
| 279 | function i(r) { |
| 280 | var n = r |
| 281 | return s.defined(n) && ge.is(n.location) && s.string(n.message) |
| 282 | } |
| 283 | e.is = i |
| 284 | })(he || (he = {})) |
| 285 | var O |
| 286 | ;(function (e) { |
| 287 | ;(e.Error = 1), (e.Warning = 2), (e.Information = 3), (e.Hint = 4) |
| 288 | })(O || (O = {})) |
| 289 | var De |
| 290 | ;(function (e) { |
| 291 | ;(e.Unnecessary = 1), (e.Deprecated = 2) |
| 292 | })(De || (De = {})) |
| 293 | var Ne |
| 294 | ;(function (e) { |
| 295 | function t(i) { |
| 296 | var r = i |
| 297 | return r != null && s.string(r.href) |
| 298 | } |
| 299 | e.is = t |
| 300 | })(Ne || (Ne = {})) |
| 301 | var se |
| 302 | ;(function (e) { |
| 303 | function t(r, n, a, o, u, c) { |
| 304 | var h = { range: r, message: n } |
| 305 | return ( |
| 306 | s.defined(a) && (h.severity = a), |
| 307 | s.defined(o) && (h.code = o), |
| 308 | s.defined(u) && (h.source = u), |
| 309 | s.defined(c) && (h.relatedInformation = c), |
| 310 | h |
| 311 | ) |
| 312 | } |
| 313 | e.create = t |
| 314 | function i(r) { |
| 315 | var n, |
| 316 | a = r |
| 317 | return ( |
| 318 | s.defined(a) && |
| 319 | y.is(a.range) && |
| 320 | s.string(a.message) && |
| 321 | (s.number(a.severity) || s.undefined(a.severity)) && |
| 322 | (s.integer(a.code) || s.string(a.code) || s.undefined(a.code)) && |
| 323 | (s.undefined(a.codeDescription) || |
| 324 | s.string((n = a.codeDescription) === null || n === void 0 ? void 0 : n.href)) && |
| 325 | (s.string(a.source) || s.undefined(a.source)) && |
| 326 | (s.undefined(a.relatedInformation) || s.typedArray(a.relatedInformation, he.is)) |
| 327 | ) |
| 328 | } |
| 329 | e.is = i |
| 330 | })(se || (se = {})) |
| 331 | var K |
| 332 | ;(function (e) { |
| 333 | function t(r, n) { |
| 334 | for (var a = [], o = 2; o < arguments.length; o++) a[o - 2] = arguments[o] |
| 335 | var u = { title: r, command: n } |
| 336 | return s.defined(a) && a.length > 0 && (u.arguments = a), u |
| 337 | } |
| 338 | e.create = t |
| 339 | function i(r) { |
| 340 | var n = r |
| 341 | return s.defined(n) && s.string(n.title) && s.string(n.command) |
| 342 | } |
| 343 | e.is = i |
| 344 | })(K || (K = {})) |
| 345 | var A |
| 346 | ;(function (e) { |
| 347 | function t(a, o) { |
| 348 | return { range: a, newText: o } |
| 349 | } |
| 350 | e.replace = t |
| 351 | function i(a, o) { |
| 352 | return { range: { start: a, end: a }, newText: o } |
| 353 | } |
| 354 | e.insert = i |
| 355 | function r(a) { |
| 356 | return { range: a, newText: '' } |
| 357 | } |
| 358 | e.del = r |
| 359 | function n(a) { |
| 360 | var o = a |
| 361 | return s.objectLiteral(o) && s.string(o.newText) && y.is(o.range) |
| 362 | } |
| 363 | e.is = n |
| 364 | })(A || (A = {})) |
| 365 | var N |
| 366 | ;(function (e) { |
| 367 | function t(r, n, a) { |
| 368 | var o = { label: r } |
| 369 | return n !== void 0 && (o.needsConfirmation = n), a !== void 0 && (o.description = a), o |
| 370 | } |
| 371 | e.create = t |
| 372 | function i(r) { |
| 373 | var n = r |
| 374 | return ( |
| 375 | n !== void 0 && |
| 376 | s.objectLiteral(n) && |
| 377 | s.string(n.label) && |
| 378 | (s.boolean(n.needsConfirmation) || n.needsConfirmation === void 0) && |
| 379 | (s.string(n.description) || n.description === void 0) |
| 380 | ) |
| 381 | } |
| 382 | e.is = i |
| 383 | })(N || (N = {})) |
| 384 | var T |
| 385 | ;(function (e) { |
| 386 | function t(i) { |
| 387 | var r = i |
| 388 | return typeof r == 'string' |
| 389 | } |
| 390 | e.is = t |
| 391 | })(T || (T = {})) |
| 392 | var S |
| 393 | ;(function (e) { |
| 394 | function t(a, o, u) { |
| 395 | return { range: a, newText: o, annotationId: u } |
| 396 | } |
| 397 | e.replace = t |
| 398 | function i(a, o, u) { |
| 399 | return { range: { start: a, end: a }, newText: o, annotationId: u } |
| 400 | } |
| 401 | e.insert = i |
| 402 | function r(a, o) { |
| 403 | return { range: a, newText: '', annotationId: o } |
| 404 | } |
| 405 | e.del = r |
| 406 | function n(a) { |
| 407 | var o = a |
| 408 | return A.is(o) && (N.is(o.annotationId) || T.is(o.annotationId)) |
| 409 | } |
| 410 | e.is = n |
| 411 | })(S || (S = {})) |
| 412 | var ue |
| 413 | ;(function (e) { |
| 414 | function t(r, n) { |
| 415 | return { textDocument: r, edits: n } |
| 416 | } |
| 417 | e.create = t |
| 418 | function i(r) { |
| 419 | var n = r |
| 420 | return s.defined(n) && ce.is(n.textDocument) && Array.isArray(n.edits) |
| 421 | } |
| 422 | e.is = i |
| 423 | })(ue || (ue = {})) |
| 424 | var H |
| 425 | ;(function (e) { |
| 426 | function t(r, n, a) { |
| 427 | var o = { kind: 'create', uri: r } |
| 428 | return ( |
| 429 | n !== void 0 && |
| 430 | (n.overwrite !== void 0 || n.ignoreIfExists !== void 0) && |
| 431 | (o.options = n), |
| 432 | a !== void 0 && (o.annotationId = a), |
| 433 | o |
| 434 | ) |
| 435 | } |
| 436 | e.create = t |
| 437 | function i(r) { |
| 438 | var n = r |
| 439 | return ( |
| 440 | n && |
| 441 | n.kind === 'create' && |
| 442 | s.string(n.uri) && |
| 443 | (n.options === void 0 || |
| 444 | ((n.options.overwrite === void 0 || s.boolean(n.options.overwrite)) && |
| 445 | (n.options.ignoreIfExists === void 0 || s.boolean(n.options.ignoreIfExists)))) && |
| 446 | (n.annotationId === void 0 || T.is(n.annotationId)) |
| 447 | ) |
| 448 | } |
| 449 | e.is = i |
| 450 | })(H || (H = {})) |
| 451 | var J |
| 452 | ;(function (e) { |
| 453 | function t(r, n, a, o) { |
| 454 | var u = { kind: 'rename', oldUri: r, newUri: n } |
| 455 | return ( |
| 456 | a !== void 0 && |
| 457 | (a.overwrite !== void 0 || a.ignoreIfExists !== void 0) && |
| 458 | (u.options = a), |
| 459 | o !== void 0 && (u.annotationId = o), |
| 460 | u |
| 461 | ) |
| 462 | } |
| 463 | e.create = t |
| 464 | function i(r) { |
| 465 | var n = r |
| 466 | return ( |
| 467 | n && |
| 468 | n.kind === 'rename' && |
| 469 | s.string(n.oldUri) && |
| 470 | s.string(n.newUri) && |
| 471 | (n.options === void 0 || |
| 472 | ((n.options.overwrite === void 0 || s.boolean(n.options.overwrite)) && |
| 473 | (n.options.ignoreIfExists === void 0 || s.boolean(n.options.ignoreIfExists)))) && |
| 474 | (n.annotationId === void 0 || T.is(n.annotationId)) |
| 475 | ) |
| 476 | } |
| 477 | e.is = i |
| 478 | })(J || (J = {})) |
| 479 | var B |
| 480 | ;(function (e) { |
| 481 | function t(r, n, a) { |
| 482 | var o = { kind: 'delete', uri: r } |
| 483 | return ( |
| 484 | n !== void 0 && |
| 485 | (n.recursive !== void 0 || n.ignoreIfNotExists !== void 0) && |
| 486 | (o.options = n), |
| 487 | a !== void 0 && (o.annotationId = a), |
| 488 | o |
| 489 | ) |
| 490 | } |
| 491 | e.create = t |
| 492 | function i(r) { |
| 493 | var n = r |
| 494 | return ( |
| 495 | n && |
| 496 | n.kind === 'delete' && |
| 497 | s.string(n.uri) && |
| 498 | (n.options === void 0 || |
| 499 | ((n.options.recursive === void 0 || s.boolean(n.options.recursive)) && |
| 500 | (n.options.ignoreIfNotExists === void 0 || |
| 501 | s.boolean(n.options.ignoreIfNotExists)))) && |
| 502 | (n.annotationId === void 0 || T.is(n.annotationId)) |
| 503 | ) |
| 504 | } |
| 505 | e.is = i |
| 506 | })(B || (B = {})) |
| 507 | var me |
| 508 | ;(function (e) { |
| 509 | function t(i) { |
| 510 | var r = i |
| 511 | return ( |
| 512 | r && |
| 513 | (r.changes !== void 0 || r.documentChanges !== void 0) && |
| 514 | (r.documentChanges === void 0 || |
| 515 | r.documentChanges.every(function (n) { |
| 516 | return s.string(n.kind) ? H.is(n) || J.is(n) || B.is(n) : ue.is(n) |
| 517 | })) |
| 518 | ) |
| 519 | } |
| 520 | e.is = t |
| 521 | })(me || (me = {})) |
| 522 | var ae = (function () { |
| 523 | function e(t, i) { |
| 524 | ;(this.edits = t), (this.changeAnnotations = i) |
| 525 | } |
| 526 | return ( |
| 527 | (e.prototype.insert = function (t, i, r) { |
| 528 | var n, a |
| 529 | if ( |
| 530 | (r === void 0 |
| 531 | ? (n = A.insert(t, i)) |
| 532 | : T.is(r) |
| 533 | ? ((a = r), (n = S.insert(t, i, r))) |
| 534 | : (this.assertChangeAnnotations(this.changeAnnotations), |
| 535 | (a = this.changeAnnotations.manage(r)), |
| 536 | (n = S.insert(t, i, a))), |
| 537 | this.edits.push(n), |
| 538 | a !== void 0) |
| 539 | ) |
| 540 | return a |
| 541 | }), |
| 542 | (e.prototype.replace = function (t, i, r) { |
| 543 | var n, a |
| 544 | if ( |
| 545 | (r === void 0 |
| 546 | ? (n = A.replace(t, i)) |
| 547 | : T.is(r) |
| 548 | ? ((a = r), (n = S.replace(t, i, r))) |
| 549 | : (this.assertChangeAnnotations(this.changeAnnotations), |
| 550 | (a = this.changeAnnotations.manage(r)), |
| 551 | (n = S.replace(t, i, a))), |
| 552 | this.edits.push(n), |
| 553 | a !== void 0) |
| 554 | ) |
| 555 | return a |
| 556 | }), |
| 557 | (e.prototype.delete = function (t, i) { |
| 558 | var r, n |
| 559 | if ( |
| 560 | (i === void 0 |
| 561 | ? (r = A.del(t)) |
| 562 | : T.is(i) |
| 563 | ? ((n = i), (r = S.del(t, i))) |
| 564 | : (this.assertChangeAnnotations(this.changeAnnotations), |
| 565 | (n = this.changeAnnotations.manage(i)), |
| 566 | (r = S.del(t, n))), |
| 567 | this.edits.push(r), |
| 568 | n !== void 0) |
| 569 | ) |
| 570 | return n |
| 571 | }), |
| 572 | (e.prototype.add = function (t) { |
| 573 | this.edits.push(t) |
| 574 | }), |
| 575 | (e.prototype.all = function () { |
| 576 | return this.edits |
| 577 | }), |
| 578 | (e.prototype.clear = function () { |
| 579 | this.edits.splice(0, this.edits.length) |
| 580 | }), |
| 581 | (e.prototype.assertChangeAnnotations = function (t) { |
| 582 | if (t === void 0) |
| 583 | throw new Error('Text edit change is not configured to manage change annotations.') |
| 584 | }), |
| 585 | e |
| 586 | ) |
| 587 | })(), |
| 588 | Me = (function () { |
| 589 | function e(t) { |
| 590 | ;(this._annotations = t === void 0 ? Object.create(null) : t), |
| 591 | (this._counter = 0), |
| 592 | (this._size = 0) |
| 593 | } |
| 594 | return ( |
| 595 | (e.prototype.all = function () { |
| 596 | return this._annotations |
| 597 | }), |
| 598 | Object.defineProperty(e.prototype, 'size', { |
| 599 | get: function () { |
| 600 | return this._size |
| 601 | }, |
| 602 | enumerable: !1, |
| 603 | configurable: !0, |
| 604 | }), |
| 605 | (e.prototype.manage = function (t, i) { |
| 606 | var r |
| 607 | if ( |
| 608 | (T.is(t) ? (r = t) : ((r = this.nextId()), (i = t)), this._annotations[r] !== void 0) |
| 609 | ) |
| 610 | throw new Error('Id ' + r + ' is already in use.') |
| 611 | if (i === void 0) throw new Error('No annotation provided for id ' + r) |
| 612 | return (this._annotations[r] = i), this._size++, r |
| 613 | }), |
| 614 | (e.prototype.nextId = function () { |
| 615 | return this._counter++, this._counter.toString() |
| 616 | }), |
| 617 | e |
| 618 | ) |
| 619 | })(), |
| 620 | kr = (function () { |
| 621 | function e(t) { |
| 622 | var i = this |
| 623 | ;(this._textEditChanges = Object.create(null)), |
| 624 | t !== void 0 |
| 625 | ? ((this._workspaceEdit = t), |
| 626 | t.documentChanges |
| 627 | ? ((this._changeAnnotations = new Me(t.changeAnnotations)), |
| 628 | (t.changeAnnotations = this._changeAnnotations.all()), |
| 629 | t.documentChanges.forEach(function (r) { |
| 630 | if (ue.is(r)) { |
| 631 | var n = new ae(r.edits, i._changeAnnotations) |
| 632 | i._textEditChanges[r.textDocument.uri] = n |
| 633 | } |
| 634 | })) |
| 635 | : t.changes && |
| 636 | Object.keys(t.changes).forEach(function (r) { |
| 637 | var n = new ae(t.changes[r]) |
| 638 | i._textEditChanges[r] = n |
| 639 | })) |
| 640 | : (this._workspaceEdit = {}) |
| 641 | } |
| 642 | return ( |
| 643 | Object.defineProperty(e.prototype, 'edit', { |
| 644 | get: function () { |
| 645 | return ( |
| 646 | this.initDocumentChanges(), |
| 647 | this._changeAnnotations !== void 0 && |
| 648 | (this._changeAnnotations.size === 0 |
| 649 | ? (this._workspaceEdit.changeAnnotations = void 0) |
| 650 | : (this._workspaceEdit.changeAnnotations = this._changeAnnotations.all())), |
| 651 | this._workspaceEdit |
| 652 | ) |
| 653 | }, |
| 654 | enumerable: !1, |
| 655 | configurable: !0, |
| 656 | }), |
| 657 | (e.prototype.getTextEditChange = function (t) { |
| 658 | if (ce.is(t)) { |
| 659 | if ((this.initDocumentChanges(), this._workspaceEdit.documentChanges === void 0)) |
| 660 | throw new Error('Workspace edit is not configured for document changes.') |
| 661 | var i = { uri: t.uri, version: t.version }, |
| 662 | r = this._textEditChanges[i.uri] |
| 663 | if (!r) { |
| 664 | var n = [], |
| 665 | a = { textDocument: i, edits: n } |
| 666 | this._workspaceEdit.documentChanges.push(a), |
| 667 | (r = new ae(n, this._changeAnnotations)), |
| 668 | (this._textEditChanges[i.uri] = r) |
| 669 | } |
| 670 | return r |
| 671 | } else { |
| 672 | if ((this.initChanges(), this._workspaceEdit.changes === void 0)) |
| 673 | throw new Error('Workspace edit is not configured for normal text edit changes.') |
| 674 | var r = this._textEditChanges[t] |
| 675 | if (!r) { |
| 676 | var n = [] |
| 677 | ;(this._workspaceEdit.changes[t] = n), |
| 678 | (r = new ae(n)), |
| 679 | (this._textEditChanges[t] = r) |
| 680 | } |
| 681 | return r |
| 682 | } |
| 683 | }), |
| 684 | (e.prototype.initDocumentChanges = function () { |
| 685 | this._workspaceEdit.documentChanges === void 0 && |
| 686 | this._workspaceEdit.changes === void 0 && |
| 687 | ((this._changeAnnotations = new Me()), |
| 688 | (this._workspaceEdit.documentChanges = []), |
| 689 | (this._workspaceEdit.changeAnnotations = this._changeAnnotations.all())) |
| 690 | }), |
| 691 | (e.prototype.initChanges = function () { |
| 692 | this._workspaceEdit.documentChanges === void 0 && |
| 693 | this._workspaceEdit.changes === void 0 && |
| 694 | (this._workspaceEdit.changes = Object.create(null)) |
| 695 | }), |
| 696 | (e.prototype.createFile = function (t, i, r) { |
| 697 | if ((this.initDocumentChanges(), this._workspaceEdit.documentChanges === void 0)) |
| 698 | throw new Error('Workspace edit is not configured for document changes.') |
| 699 | var n |
| 700 | N.is(i) || T.is(i) ? (n = i) : (r = i) |
| 701 | var a, o |
| 702 | if ( |
| 703 | (n === void 0 |
| 704 | ? (a = H.create(t, r)) |
| 705 | : ((o = T.is(n) ? n : this._changeAnnotations.manage(n)), (a = H.create(t, r, o))), |
| 706 | this._workspaceEdit.documentChanges.push(a), |
| 707 | o !== void 0) |
| 708 | ) |
| 709 | return o |
| 710 | }), |
| 711 | (e.prototype.renameFile = function (t, i, r, n) { |
| 712 | if ((this.initDocumentChanges(), this._workspaceEdit.documentChanges === void 0)) |
| 713 | throw new Error('Workspace edit is not configured for document changes.') |
| 714 | var a |
| 715 | N.is(r) || T.is(r) ? (a = r) : (n = r) |
| 716 | var o, u |
| 717 | if ( |
| 718 | (a === void 0 |
| 719 | ? (o = J.create(t, i, n)) |
| 720 | : ((u = T.is(a) ? a : this._changeAnnotations.manage(a)), |
| 721 | (o = J.create(t, i, n, u))), |
| 722 | this._workspaceEdit.documentChanges.push(o), |
| 723 | u !== void 0) |
| 724 | ) |
| 725 | return u |
| 726 | }), |
| 727 | (e.prototype.deleteFile = function (t, i, r) { |
| 728 | if ((this.initDocumentChanges(), this._workspaceEdit.documentChanges === void 0)) |
| 729 | throw new Error('Workspace edit is not configured for document changes.') |
| 730 | var n |
| 731 | N.is(i) || T.is(i) ? (n = i) : (r = i) |
| 732 | var a, o |
| 733 | if ( |
| 734 | (n === void 0 |
| 735 | ? (a = B.create(t, r)) |
| 736 | : ((o = T.is(n) ? n : this._changeAnnotations.manage(n)), (a = B.create(t, r, o))), |
| 737 | this._workspaceEdit.documentChanges.push(a), |
| 738 | o !== void 0) |
| 739 | ) |
| 740 | return o |
| 741 | }), |
| 742 | e |
| 743 | ) |
| 744 | })() |
| 745 | var Fe |
| 746 | ;(function (e) { |
| 747 | function t(r) { |
| 748 | return { uri: r } |
| 749 | } |
| 750 | e.create = t |
| 751 | function i(r) { |
| 752 | var n = r |
| 753 | return s.defined(n) && s.string(n.uri) |
| 754 | } |
| 755 | e.is = i |
| 756 | })(Fe || (Fe = {})) |
| 757 | var je |
| 758 | ;(function (e) { |
| 759 | function t(r, n) { |
| 760 | return { uri: r, version: n } |
| 761 | } |
| 762 | e.create = t |
| 763 | function i(r) { |
| 764 | var n = r |
| 765 | return s.defined(n) && s.string(n.uri) && s.integer(n.version) |
| 766 | } |
| 767 | e.is = i |
| 768 | })(je || (je = {})) |
| 769 | var ce |
| 770 | ;(function (e) { |
| 771 | function t(r, n) { |
| 772 | return { uri: r, version: n } |
| 773 | } |
| 774 | e.create = t |
| 775 | function i(r) { |
| 776 | var n = r |
| 777 | return s.defined(n) && s.string(n.uri) && (n.version === null || s.integer(n.version)) |
| 778 | } |
| 779 | e.is = i |
| 780 | })(ce || (ce = {})) |
| 781 | var Ue |
| 782 | ;(function (e) { |
| 783 | function t(r, n, a, o) { |
| 784 | return { uri: r, languageId: n, version: a, text: o } |
| 785 | } |
| 786 | e.create = t |
| 787 | function i(r) { |
| 788 | var n = r |
| 789 | return ( |
| 790 | s.defined(n) && |
| 791 | s.string(n.uri) && |
| 792 | s.string(n.languageId) && |
| 793 | s.integer(n.version) && |
| 794 | s.string(n.text) |
| 795 | ) |
| 796 | } |
| 797 | e.is = i |
| 798 | })(Ue || (Ue = {})) |
| 799 | var z |
| 800 | ;(function (e) { |
| 801 | ;(e.PlainText = 'plaintext'), (e.Markdown = 'markdown') |
| 802 | })(z || (z = {})) |
| 803 | ;(function (e) { |
| 804 | function t(i) { |
| 805 | var r = i |
| 806 | return r === e.PlainText || r === e.Markdown |
| 807 | } |
| 808 | e.is = t |
| 809 | })(z || (z = {})) |
| 810 | var ve |
| 811 | ;(function (e) { |
| 812 | function t(i) { |
| 813 | var r = i |
| 814 | return s.objectLiteral(i) && z.is(r.kind) && s.string(r.value) |
| 815 | } |
| 816 | e.is = t |
| 817 | })(ve || (ve = {})) |
| 818 | var m |
| 819 | ;(function (e) { |
| 820 | ;(e.Text = 1), |
| 821 | (e.Method = 2), |
| 822 | (e.Function = 3), |
| 823 | (e.Constructor = 4), |
| 824 | (e.Field = 5), |
| 825 | (e.Variable = 6), |
| 826 | (e.Class = 7), |
| 827 | (e.Interface = 8), |
| 828 | (e.Module = 9), |
| 829 | (e.Property = 10), |
| 830 | (e.Unit = 11), |
| 831 | (e.Value = 12), |
| 832 | (e.Enum = 13), |
| 833 | (e.Keyword = 14), |
| 834 | (e.Snippet = 15), |
| 835 | (e.Color = 16), |
| 836 | (e.File = 17), |
| 837 | (e.Reference = 18), |
| 838 | (e.Folder = 19), |
| 839 | (e.EnumMember = 20), |
| 840 | (e.Constant = 21), |
| 841 | (e.Struct = 22), |
| 842 | (e.Event = 23), |
| 843 | (e.Operator = 24), |
| 844 | (e.TypeParameter = 25) |
| 845 | })(m || (m = {})) |
| 846 | var le |
| 847 | ;(function (e) { |
| 848 | ;(e.PlainText = 1), (e.Snippet = 2) |
| 849 | })(le || (le = {})) |
| 850 | var Ve |
| 851 | ;(function (e) { |
| 852 | e.Deprecated = 1 |
| 853 | })(Ve || (Ve = {})) |
| 854 | var Ke |
| 855 | ;(function (e) { |
| 856 | function t(r, n, a) { |
| 857 | return { newText: r, insert: n, replace: a } |
| 858 | } |
| 859 | e.create = t |
| 860 | function i(r) { |
| 861 | var n = r |
| 862 | return n && s.string(n.newText) && y.is(n.insert) && y.is(n.replace) |
| 863 | } |
| 864 | e.is = i |
| 865 | })(Ke || (Ke = {})) |
| 866 | var He |
| 867 | ;(function (e) { |
| 868 | ;(e.asIs = 1), (e.adjustIndentation = 2) |
| 869 | })(He || (He = {})) |
| 870 | var Je |
| 871 | ;(function (e) { |
| 872 | function t(i) { |
| 873 | return { label: i } |
| 874 | } |
| 875 | e.create = t |
| 876 | })(Je || (Je = {})) |
| 877 | var Be |
| 878 | ;(function (e) { |
| 879 | function t(i, r) { |
| 880 | return { items: i || [], isIncomplete: !!r } |
| 881 | } |
| 882 | e.create = t |
| 883 | })(Be || (Be = {})) |
| 884 | var fe |
| 885 | ;(function (e) { |
| 886 | function t(r) { |
| 887 | return r.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&') |
| 888 | } |
| 889 | e.fromPlainText = t |
| 890 | function i(r) { |
| 891 | var n = r |
| 892 | return s.string(n) || (s.objectLiteral(n) && s.string(n.language) && s.string(n.value)) |
| 893 | } |
| 894 | e.is = i |
| 895 | })(fe || (fe = {})) |
| 896 | var ze |
| 897 | ;(function (e) { |
| 898 | function t(i) { |
| 899 | var r = i |
| 900 | return ( |
| 901 | !!r && |
| 902 | s.objectLiteral(r) && |
| 903 | (ve.is(r.contents) || fe.is(r.contents) || s.typedArray(r.contents, fe.is)) && |
| 904 | (i.range === void 0 || y.is(i.range)) |
| 905 | ) |
| 906 | } |
| 907 | e.is = t |
| 908 | })(ze || (ze = {})) |
| 909 | var qe |
| 910 | ;(function (e) { |
| 911 | function t(i, r) { |
| 912 | return r ? { label: i, documentation: r } : { label: i } |
| 913 | } |
| 914 | e.create = t |
| 915 | })(qe || (qe = {})) |
| 916 | var Xe |
| 917 | ;(function (e) { |
| 918 | function t(i, r) { |
| 919 | for (var n = [], a = 2; a < arguments.length; a++) n[a - 2] = arguments[a] |
| 920 | var o = { label: i } |
| 921 | return ( |
| 922 | s.defined(r) && (o.documentation = r), |
| 923 | s.defined(n) ? (o.parameters = n) : (o.parameters = []), |
| 924 | o |
| 925 | ) |
| 926 | } |
| 927 | e.create = t |
| 928 | })(Xe || (Xe = {})) |
| 929 | var F |
| 930 | ;(function (e) { |
| 931 | ;(e.Text = 1), (e.Read = 2), (e.Write = 3) |
| 932 | })(F || (F = {})) |
| 933 | var Ye |
| 934 | ;(function (e) { |
| 935 | function t(i, r) { |
| 936 | var n = { range: i } |
| 937 | return s.number(r) && (n.kind = r), n |
| 938 | } |
| 939 | e.create = t |
| 940 | })(Ye || (Ye = {})) |
| 941 | var v |
| 942 | ;(function (e) { |
| 943 | ;(e.File = 1), |
| 944 | (e.Module = 2), |
| 945 | (e.Namespace = 3), |
| 946 | (e.Package = 4), |
| 947 | (e.Class = 5), |
| 948 | (e.Method = 6), |
| 949 | (e.Property = 7), |
| 950 | (e.Field = 8), |
| 951 | (e.Constructor = 9), |
| 952 | (e.Enum = 10), |
| 953 | (e.Interface = 11), |
| 954 | (e.Function = 12), |
| 955 | (e.Variable = 13), |
| 956 | (e.Constant = 14), |
| 957 | (e.String = 15), |
| 958 | (e.Number = 16), |
| 959 | (e.Boolean = 17), |
| 960 | (e.Array = 18), |
| 961 | (e.Object = 19), |
| 962 | (e.Key = 20), |
| 963 | (e.Null = 21), |
| 964 | (e.EnumMember = 22), |
| 965 | (e.Struct = 23), |
| 966 | (e.Event = 24), |
| 967 | (e.Operator = 25), |
| 968 | (e.TypeParameter = 26) |
| 969 | })(v || (v = {})) |
| 970 | var $e |
| 971 | ;(function (e) { |
| 972 | e.Deprecated = 1 |
| 973 | })($e || ($e = {})) |
| 974 | var Ge |
| 975 | ;(function (e) { |
| 976 | function t(i, r, n, a, o) { |
| 977 | var u = { name: i, kind: r, location: { uri: a, range: n } } |
| 978 | return o && (u.containerName = o), u |
| 979 | } |
| 980 | e.create = t |
| 981 | })(Ge || (Ge = {})) |
| 982 | var Qe |
| 983 | ;(function (e) { |
| 984 | function t(r, n, a, o, u, c) { |
| 985 | var h = { name: r, detail: n, kind: a, range: o, selectionRange: u } |
| 986 | return c !== void 0 && (h.children = c), h |
| 987 | } |
| 988 | e.create = t |
| 989 | function i(r) { |
| 990 | var n = r |
| 991 | return ( |
| 992 | n && |
| 993 | s.string(n.name) && |
| 994 | s.number(n.kind) && |
| 995 | y.is(n.range) && |
| 996 | y.is(n.selectionRange) && |
| 997 | (n.detail === void 0 || s.string(n.detail)) && |
| 998 | (n.deprecated === void 0 || s.boolean(n.deprecated)) && |
| 999 | (n.children === void 0 || Array.isArray(n.children)) && |
| 1000 | (n.tags === void 0 || Array.isArray(n.tags)) |
| 1001 | ) |
| 1002 | } |
| 1003 | e.is = i |
| 1004 | })(Qe || (Qe = {})) |
| 1005 | var Ze |
| 1006 | ;(function (e) { |
| 1007 | ;(e.Empty = ''), |
| 1008 | (e.QuickFix = 'quickfix'), |
| 1009 | (e.Refactor = 'refactor'), |
| 1010 | (e.RefactorExtract = 'refactor.extract'), |
| 1011 | (e.RefactorInline = 'refactor.inline'), |
| 1012 | (e.RefactorRewrite = 'refactor.rewrite'), |
| 1013 | (e.Source = 'source'), |
| 1014 | (e.SourceOrganizeImports = 'source.organizeImports'), |
| 1015 | (e.SourceFixAll = 'source.fixAll') |
| 1016 | })(Ze || (Ze = {})) |
| 1017 | var en |
| 1018 | ;(function (e) { |
| 1019 | function t(r, n) { |
| 1020 | var a = { diagnostics: r } |
| 1021 | return n != null && (a.only = n), a |
| 1022 | } |
| 1023 | e.create = t |
| 1024 | function i(r) { |
| 1025 | var n = r |
| 1026 | return ( |
| 1027 | s.defined(n) && |
| 1028 | s.typedArray(n.diagnostics, se.is) && |
| 1029 | (n.only === void 0 || s.typedArray(n.only, s.string)) |
| 1030 | ) |
| 1031 | } |
| 1032 | e.is = i |
| 1033 | })(en || (en = {})) |
| 1034 | var nn |
| 1035 | ;(function (e) { |
| 1036 | function t(r, n, a) { |
| 1037 | var o = { title: r }, |
| 1038 | u = !0 |
| 1039 | return ( |
| 1040 | typeof n == 'string' |
| 1041 | ? ((u = !1), (o.kind = n)) |
| 1042 | : K.is(n) |
| 1043 | ? (o.command = n) |
| 1044 | : (o.edit = n), |
| 1045 | u && a !== void 0 && (o.kind = a), |
| 1046 | o |
| 1047 | ) |
| 1048 | } |
| 1049 | e.create = t |
| 1050 | function i(r) { |
| 1051 | var n = r |
| 1052 | return ( |
| 1053 | n && |
| 1054 | s.string(n.title) && |
| 1055 | (n.diagnostics === void 0 || s.typedArray(n.diagnostics, se.is)) && |
| 1056 | (n.kind === void 0 || s.string(n.kind)) && |
| 1057 | (n.edit !== void 0 || n.command !== void 0) && |
| 1058 | (n.command === void 0 || K.is(n.command)) && |
| 1059 | (n.isPreferred === void 0 || s.boolean(n.isPreferred)) && |
| 1060 | (n.edit === void 0 || me.is(n.edit)) |
| 1061 | ) |
| 1062 | } |
| 1063 | e.is = i |
| 1064 | })(nn || (nn = {})) |
| 1065 | var rn |
| 1066 | ;(function (e) { |
| 1067 | function t(r, n) { |
| 1068 | var a = { range: r } |
| 1069 | return s.defined(n) && (a.data = n), a |
| 1070 | } |
| 1071 | e.create = t |
| 1072 | function i(r) { |
| 1073 | var n = r |
| 1074 | return s.defined(n) && y.is(n.range) && (s.undefined(n.command) || K.is(n.command)) |
| 1075 | } |
| 1076 | e.is = i |
| 1077 | })(rn || (rn = {})) |
| 1078 | var tn |
| 1079 | ;(function (e) { |
| 1080 | function t(r, n) { |
| 1081 | return { tabSize: r, insertSpaces: n } |
| 1082 | } |
| 1083 | e.create = t |
| 1084 | function i(r) { |
| 1085 | var n = r |
| 1086 | return s.defined(n) && s.uinteger(n.tabSize) && s.boolean(n.insertSpaces) |
| 1087 | } |
| 1088 | e.is = i |
| 1089 | })(tn || (tn = {})) |
| 1090 | var an |
| 1091 | ;(function (e) { |
| 1092 | function t(r, n, a) { |
| 1093 | return { range: r, target: n, data: a } |
| 1094 | } |
| 1095 | e.create = t |
| 1096 | function i(r) { |
| 1097 | var n = r |
| 1098 | return s.defined(n) && y.is(n.range) && (s.undefined(n.target) || s.string(n.target)) |
| 1099 | } |
| 1100 | e.is = i |
| 1101 | })(an || (an = {})) |
| 1102 | var on |
| 1103 | ;(function (e) { |
| 1104 | function t(r, n) { |
| 1105 | return { range: r, parent: n } |
| 1106 | } |
| 1107 | e.create = t |
| 1108 | function i(r) { |
| 1109 | var n = r |
| 1110 | return n !== void 0 && y.is(n.range) && (n.parent === void 0 || e.is(n.parent)) |
| 1111 | } |
| 1112 | e.is = i |
| 1113 | })(on || (on = {})) |
| 1114 | var sn |
| 1115 | ;(function (e) { |
| 1116 | function t(a, o, u, c) { |
| 1117 | return new Ln(a, o, u, c) |
| 1118 | } |
| 1119 | e.create = t |
| 1120 | function i(a) { |
| 1121 | var o = a |
| 1122 | return !!( |
| 1123 | s.defined(o) && |
| 1124 | s.string(o.uri) && |
| 1125 | (s.undefined(o.languageId) || s.string(o.languageId)) && |
| 1126 | s.uinteger(o.lineCount) && |
| 1127 | s.func(o.getText) && |
| 1128 | s.func(o.positionAt) && |
| 1129 | s.func(o.offsetAt) |
| 1130 | ) |
| 1131 | } |
| 1132 | e.is = i |
| 1133 | function r(a, o) { |
| 1134 | for ( |
| 1135 | var u = a.getText(), |
| 1136 | c = n(o, function (E, R) { |
| 1137 | var V = E.range.start.line - R.range.start.line |
| 1138 | return V === 0 ? E.range.start.character - R.range.start.character : V |
| 1139 | }), |
| 1140 | h = u.length, |
| 1141 | p = c.length - 1; |
| 1142 | p >= 0; |
| 1143 | p-- |
| 1144 | ) { |
| 1145 | var f = c[p], |
| 1146 | b = a.offsetAt(f.range.start), |
| 1147 | g = a.offsetAt(f.range.end) |
| 1148 | if (g <= h) u = u.substring(0, b) + f.newText + u.substring(g, u.length) |
| 1149 | else throw new Error('Overlapping edit') |
| 1150 | h = b |
| 1151 | } |
| 1152 | return u |
| 1153 | } |
| 1154 | e.applyEdits = r |
| 1155 | function n(a, o) { |
| 1156 | if (a.length <= 1) return a |
| 1157 | var u = (a.length / 2) | 0, |
| 1158 | c = a.slice(0, u), |
| 1159 | h = a.slice(u) |
| 1160 | n(c, o), n(h, o) |
| 1161 | for (var p = 0, f = 0, b = 0; p < c.length && f < h.length; ) { |
| 1162 | var g = o(c[p], h[f]) |
| 1163 | g <= 0 ? (a[b++] = c[p++]) : (a[b++] = h[f++]) |
| 1164 | } |
| 1165 | for (; p < c.length; ) a[b++] = c[p++] |
| 1166 | for (; f < h.length; ) a[b++] = h[f++] |
| 1167 | return a |
| 1168 | } |
| 1169 | })(sn || (sn = {})) |
| 1170 | var Ln = (function () { |
| 1171 | function e(t, i, r, n) { |
| 1172 | ;(this._uri = t), |
| 1173 | (this._languageId = i), |
| 1174 | (this._version = r), |
| 1175 | (this._content = n), |
| 1176 | (this._lineOffsets = void 0) |
| 1177 | } |
| 1178 | return ( |
| 1179 | Object.defineProperty(e.prototype, 'uri', { |
| 1180 | get: function () { |
| 1181 | return this._uri |
| 1182 | }, |
| 1183 | enumerable: !1, |
| 1184 | configurable: !0, |
| 1185 | }), |
| 1186 | Object.defineProperty(e.prototype, 'languageId', { |
| 1187 | get: function () { |
| 1188 | return this._languageId |
| 1189 | }, |
| 1190 | enumerable: !1, |
| 1191 | configurable: !0, |
| 1192 | }), |
| 1193 | Object.defineProperty(e.prototype, 'version', { |
| 1194 | get: function () { |
| 1195 | return this._version |
| 1196 | }, |
| 1197 | enumerable: !1, |
| 1198 | configurable: !0, |
| 1199 | }), |
| 1200 | (e.prototype.getText = function (t) { |
| 1201 | if (t) { |
| 1202 | var i = this.offsetAt(t.start), |
| 1203 | r = this.offsetAt(t.end) |
| 1204 | return this._content.substring(i, r) |
| 1205 | } |
| 1206 | return this._content |
| 1207 | }), |
| 1208 | (e.prototype.update = function (t, i) { |
| 1209 | ;(this._content = t.text), (this._version = i), (this._lineOffsets = void 0) |
| 1210 | }), |
| 1211 | (e.prototype.getLineOffsets = function () { |
| 1212 | if (this._lineOffsets === void 0) { |
| 1213 | for (var t = [], i = this._content, r = !0, n = 0; n < i.length; n++) { |
| 1214 | r && (t.push(n), (r = !1)) |
| 1215 | var a = i.charAt(n) |
| 1216 | ;(r = |
| 1217 | a === '\r' || |
| 1218 | a === |
| 1219 | ` |
| 1220 | `), |
| 1221 | a === '\r' && |
| 1222 | n + 1 < i.length && |
| 1223 | i.charAt(n + 1) === |
| 1224 | ` |
| 1225 | ` && |
| 1226 | n++ |
| 1227 | } |
| 1228 | r && i.length > 0 && t.push(i.length), (this._lineOffsets = t) |
| 1229 | } |
| 1230 | return this._lineOffsets |
| 1231 | }), |
| 1232 | (e.prototype.positionAt = function (t) { |
| 1233 | t = Math.max(Math.min(t, this._content.length), 0) |
| 1234 | var i = this.getLineOffsets(), |
| 1235 | r = 0, |
| 1236 | n = i.length |
| 1237 | if (n === 0) return _.create(0, t) |
| 1238 | for (; r < n; ) { |
| 1239 | var a = Math.floor((r + n) / 2) |
| 1240 | i[a] > t ? (n = a) : (r = a + 1) |
| 1241 | } |
| 1242 | var o = r - 1 |
| 1243 | return _.create(o, t - i[o]) |
| 1244 | }), |
| 1245 | (e.prototype.offsetAt = function (t) { |
| 1246 | var i = this.getLineOffsets() |
| 1247 | if (t.line >= i.length) return this._content.length |
| 1248 | if (t.line < 0) return 0 |
| 1249 | var r = i[t.line], |
| 1250 | n = t.line + 1 < i.length ? i[t.line + 1] : this._content.length |
| 1251 | return Math.max(Math.min(r + t.character, n), r) |
| 1252 | }), |
| 1253 | Object.defineProperty(e.prototype, 'lineCount', { |
| 1254 | get: function () { |
| 1255 | return this.getLineOffsets().length |
| 1256 | }, |
| 1257 | enumerable: !1, |
| 1258 | configurable: !0, |
| 1259 | }), |
| 1260 | e |
| 1261 | ) |
| 1262 | })(), |
| 1263 | s |
| 1264 | ;(function (e) { |
| 1265 | var t = Object.prototype.toString |
| 1266 | function i(g) { |
| 1267 | return typeof g < 'u' |
| 1268 | } |
| 1269 | e.defined = i |
| 1270 | function r(g) { |
| 1271 | return typeof g > 'u' |
| 1272 | } |
| 1273 | e.undefined = r |
| 1274 | function n(g) { |
| 1275 | return g === !0 || g === !1 |
| 1276 | } |
| 1277 | e.boolean = n |
| 1278 | function a(g) { |
| 1279 | return t.call(g) === '[object String]' |
| 1280 | } |
| 1281 | e.string = a |
| 1282 | function o(g) { |
| 1283 | return t.call(g) === '[object Number]' |
| 1284 | } |
| 1285 | e.number = o |
| 1286 | function u(g, E, R) { |
| 1287 | return t.call(g) === '[object Number]' && E <= g && g <= R |
| 1288 | } |
| 1289 | e.numberRange = u |
| 1290 | function c(g) { |
| 1291 | return t.call(g) === '[object Number]' && -2147483648 <= g && g <= 2147483647 |
| 1292 | } |
| 1293 | e.integer = c |
| 1294 | function h(g) { |
| 1295 | return t.call(g) === '[object Number]' && 0 <= g && g <= 2147483647 |
| 1296 | } |
| 1297 | e.uinteger = h |
| 1298 | function p(g) { |
| 1299 | return t.call(g) === '[object Function]' |
| 1300 | } |
| 1301 | e.func = p |
| 1302 | function f(g) { |
| 1303 | return g !== null && typeof g == 'object' |
| 1304 | } |
| 1305 | e.objectLiteral = f |
| 1306 | function b(g, E) { |
| 1307 | return Array.isArray(g) && g.every(E) |
| 1308 | } |
| 1309 | e.typedArray = b |
| 1310 | })(s || (s = {})) |
| 1311 | var q = class { |
| 1312 | constructor(t, i, r) { |
| 1313 | this._languageId = t |
| 1314 | this._worker = i |
| 1315 | let n = (o) => { |
| 1316 | let u = o.getLanguageId() |
| 1317 | if (u !== this._languageId) return |
| 1318 | let c |
| 1319 | ;(this._listener[o.uri.toString()] = o.onDidChangeContent(() => { |
| 1320 | window.clearTimeout(c), (c = window.setTimeout(() => this._doValidate(o.uri, u), 500)) |
| 1321 | })), |
| 1322 | this._doValidate(o.uri, u) |
| 1323 | }, |
| 1324 | a = (o) => { |
| 1325 | l.editor.setModelMarkers(o, this._languageId, []) |
| 1326 | let u = o.uri.toString(), |
| 1327 | c = this._listener[u] |
| 1328 | c && (c.dispose(), delete this._listener[u]) |
| 1329 | } |
| 1330 | this._disposables.push(l.editor.onDidCreateModel(n)), |
| 1331 | this._disposables.push(l.editor.onWillDisposeModel(a)), |
| 1332 | this._disposables.push( |
| 1333 | l.editor.onDidChangeModelLanguage((o) => { |
| 1334 | a(o.model), n(o.model) |
| 1335 | }) |
| 1336 | ), |
| 1337 | this._disposables.push( |
| 1338 | r((o) => { |
| 1339 | l.editor.getModels().forEach((u) => { |
| 1340 | u.getLanguageId() === this._languageId && (a(u), n(u)) |
| 1341 | }) |
| 1342 | }) |
| 1343 | ), |
| 1344 | this._disposables.push({ |
| 1345 | dispose: () => { |
| 1346 | l.editor.getModels().forEach(a) |
| 1347 | for (let o in this._listener) this._listener[o].dispose() |
| 1348 | }, |
| 1349 | }), |
| 1350 | l.editor.getModels().forEach(n) |
| 1351 | } |
| 1352 | _disposables = [] |
| 1353 | _listener = Object.create(null) |
| 1354 | dispose() { |
| 1355 | this._disposables.forEach((t) => t && t.dispose()), (this._disposables.length = 0) |
| 1356 | } |
| 1357 | _doValidate(t, i) { |
| 1358 | this._worker(t) |
| 1359 | .then((r) => r.doValidation(t.toString())) |
| 1360 | .then((r) => { |
| 1361 | let n = r.map((o) => Rn(t, o)), |
| 1362 | a = l.editor.getModel(t) |
| 1363 | a && a.getLanguageId() === i && l.editor.setModelMarkers(a, i, n) |
| 1364 | }) |
| 1365 | .then(void 0, (r) => { |
| 1366 | console.error(r) |
| 1367 | }) |
| 1368 | } |
| 1369 | } |
| 1370 | function Wn(e) { |
| 1371 | switch (e) { |
| 1372 | case O.Error: |
| 1373 | return l.MarkerSeverity.Error |
| 1374 | case O.Warning: |
| 1375 | return l.MarkerSeverity.Warning |
| 1376 | case O.Information: |
| 1377 | return l.MarkerSeverity.Info |
| 1378 | case O.Hint: |
| 1379 | return l.MarkerSeverity.Hint |
| 1380 | default: |
| 1381 | return l.MarkerSeverity.Info |
| 1382 | } |
| 1383 | } |
| 1384 | function Rn(e, t) { |
| 1385 | let i = typeof t.code == 'number' ? String(t.code) : t.code |
| 1386 | return { |
| 1387 | severity: Wn(t.severity), |
| 1388 | startLineNumber: t.range.start.line + 1, |
| 1389 | startColumn: t.range.start.character + 1, |
| 1390 | endLineNumber: t.range.end.line + 1, |
| 1391 | endColumn: t.range.end.character + 1, |
| 1392 | message: t.message, |
| 1393 | code: i, |
| 1394 | source: t.source, |
| 1395 | } |
| 1396 | } |
| 1397 | var X = class { |
| 1398 | constructor(t, i) { |
| 1399 | this._worker = t |
| 1400 | this._triggerCharacters = i |
| 1401 | } |
| 1402 | get triggerCharacters() { |
| 1403 | return this._triggerCharacters |
| 1404 | } |
| 1405 | provideCompletionItems(t, i, r, n) { |
| 1406 | let a = t.uri |
| 1407 | return this._worker(a) |
| 1408 | .then((o) => o.doComplete(a.toString(), L(i))) |
| 1409 | .then((o) => { |
| 1410 | if (!o) return |
| 1411 | let u = t.getWordUntilPosition(i), |
| 1412 | c = new l.Range(i.lineNumber, u.startColumn, i.lineNumber, u.endColumn), |
| 1413 | h = o.items.map((p) => { |
| 1414 | let f = { |
| 1415 | label: p.label, |
| 1416 | insertText: p.insertText || p.label, |
| 1417 | sortText: p.sortText, |
| 1418 | filterText: p.filterText, |
| 1419 | documentation: p.documentation, |
| 1420 | detail: p.detail, |
| 1421 | command: Mn(p.command), |
| 1422 | range: c, |
| 1423 | kind: Nn(p.kind), |
| 1424 | } |
| 1425 | return ( |
| 1426 | p.textEdit && |
| 1427 | (Dn(p.textEdit) |
| 1428 | ? (f.range = { insert: C(p.textEdit.insert), replace: C(p.textEdit.replace) }) |
| 1429 | : (f.range = C(p.textEdit.range)), |
| 1430 | (f.insertText = p.textEdit.newText)), |
| 1431 | p.additionalTextEdits && (f.additionalTextEdits = p.additionalTextEdits.map(j)), |
| 1432 | p.insertTextFormat === le.Snippet && |
| 1433 | (f.insertTextRules = l.languages.CompletionItemInsertTextRule.InsertAsSnippet), |
| 1434 | f |
| 1435 | ) |
| 1436 | }) |
| 1437 | return { isIncomplete: o.isIncomplete, suggestions: h } |
| 1438 | }) |
| 1439 | } |
| 1440 | } |
| 1441 | function L(e) { |
| 1442 | if (!!e) return { character: e.column - 1, line: e.lineNumber - 1 } |
| 1443 | } |
| 1444 | function we(e) { |
| 1445 | if (!!e) |
| 1446 | return { |
| 1447 | start: { line: e.startLineNumber - 1, character: e.startColumn - 1 }, |
| 1448 | end: { line: e.endLineNumber - 1, character: e.endColumn - 1 }, |
| 1449 | } |
| 1450 | } |
| 1451 | function C(e) { |
| 1452 | if (!!e) |
| 1453 | return new l.Range( |
| 1454 | e.start.line + 1, |
| 1455 | e.start.character + 1, |
| 1456 | e.end.line + 1, |
| 1457 | e.end.character + 1 |
| 1458 | ) |
| 1459 | } |
| 1460 | function Dn(e) { |
| 1461 | return typeof e.insert < 'u' && typeof e.replace < 'u' |
| 1462 | } |
| 1463 | function Nn(e) { |
| 1464 | let t = l.languages.CompletionItemKind |
| 1465 | switch (e) { |
| 1466 | case m.Text: |
| 1467 | return t.Text |
| 1468 | case m.Method: |
| 1469 | return t.Method |
| 1470 | case m.Function: |
| 1471 | return t.Function |
| 1472 | case m.Constructor: |
| 1473 | return t.Constructor |
| 1474 | case m.Field: |
| 1475 | return t.Field |
| 1476 | case m.Variable: |
| 1477 | return t.Variable |
| 1478 | case m.Class: |
| 1479 | return t.Class |
| 1480 | case m.Interface: |
| 1481 | return t.Interface |
| 1482 | case m.Module: |
| 1483 | return t.Module |
| 1484 | case m.Property: |
| 1485 | return t.Property |
| 1486 | case m.Unit: |
| 1487 | return t.Unit |
| 1488 | case m.Value: |
| 1489 | return t.Value |
| 1490 | case m.Enum: |
| 1491 | return t.Enum |
| 1492 | case m.Keyword: |
| 1493 | return t.Keyword |
| 1494 | case m.Snippet: |
| 1495 | return t.Snippet |
| 1496 | case m.Color: |
| 1497 | return t.Color |
| 1498 | case m.File: |
| 1499 | return t.File |
| 1500 | case m.Reference: |
| 1501 | return t.Reference |
| 1502 | } |
| 1503 | return t.Property |
| 1504 | } |
| 1505 | function j(e) { |
| 1506 | if (!!e) return { range: C(e.range), text: e.newText } |
| 1507 | } |
| 1508 | function Mn(e) { |
| 1509 | return e && e.command === 'editor.action.triggerSuggest' |
| 1510 | ? { id: e.command, title: e.title, arguments: e.arguments } |
| 1511 | : void 0 |
| 1512 | } |
| 1513 | var Y = class { |
| 1514 | constructor(t) { |
| 1515 | this._worker = t |
| 1516 | } |
| 1517 | provideHover(t, i, r) { |
| 1518 | let n = t.uri |
| 1519 | return this._worker(n) |
| 1520 | .then((a) => a.doHover(n.toString(), L(i))) |
| 1521 | .then((a) => { |
| 1522 | if (!!a) return { range: C(a.range), contents: jn(a.contents) } |
| 1523 | }) |
| 1524 | } |
| 1525 | } |
| 1526 | function Fn(e) { |
| 1527 | return e && typeof e == 'object' && typeof e.kind == 'string' |
| 1528 | } |
| 1529 | function un(e) { |
| 1530 | return typeof e == 'string' |
| 1531 | ? { value: e } |
| 1532 | : Fn(e) |
| 1533 | ? e.kind === 'plaintext' |
| 1534 | ? { value: e.value.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&') } |
| 1535 | : { value: e.value } |
| 1536 | : { |
| 1537 | value: |
| 1538 | '```' + |
| 1539 | e.language + |
| 1540 | ` |
| 1541 | ` + |
| 1542 | e.value + |
| 1543 | '\n```\n', |
| 1544 | } |
| 1545 | } |
| 1546 | function jn(e) { |
| 1547 | if (!!e) return Array.isArray(e) ? e.map(un) : [un(e)] |
| 1548 | } |
| 1549 | var ye = class { |
| 1550 | constructor(t) { |
| 1551 | this._worker = t |
| 1552 | } |
| 1553 | provideDocumentHighlights(t, i, r) { |
| 1554 | let n = t.uri |
| 1555 | return this._worker(n) |
| 1556 | .then((a) => a.findDocumentHighlights(n.toString(), L(i))) |
| 1557 | .then((a) => { |
| 1558 | if (!!a) return a.map((o) => ({ range: C(o.range), kind: Un(o.kind) })) |
| 1559 | }) |
| 1560 | } |
| 1561 | } |
| 1562 | function Un(e) { |
| 1563 | switch (e) { |
| 1564 | case F.Read: |
| 1565 | return l.languages.DocumentHighlightKind.Read |
| 1566 | case F.Write: |
| 1567 | return l.languages.DocumentHighlightKind.Write |
| 1568 | case F.Text: |
| 1569 | return l.languages.DocumentHighlightKind.Text |
| 1570 | } |
| 1571 | return l.languages.DocumentHighlightKind.Text |
| 1572 | } |
| 1573 | var ke = class { |
| 1574 | constructor(t) { |
| 1575 | this._worker = t |
| 1576 | } |
| 1577 | provideDefinition(t, i, r) { |
| 1578 | let n = t.uri |
| 1579 | return this._worker(n) |
| 1580 | .then((a) => a.findDefinition(n.toString(), L(i))) |
| 1581 | .then((a) => { |
| 1582 | if (!!a) return [cn(a)] |
| 1583 | }) |
| 1584 | } |
| 1585 | } |
| 1586 | function cn(e) { |
| 1587 | return { uri: l.Uri.parse(e.uri), range: C(e.range) } |
| 1588 | } |
| 1589 | var Te = class { |
| 1590 | constructor(t) { |
| 1591 | this._worker = t |
| 1592 | } |
| 1593 | provideReferences(t, i, r, n) { |
| 1594 | let a = t.uri |
| 1595 | return this._worker(a) |
| 1596 | .then((o) => o.findReferences(a.toString(), L(i))) |
| 1597 | .then((o) => { |
| 1598 | if (!!o) return o.map(cn) |
| 1599 | }) |
| 1600 | } |
| 1601 | }, |
| 1602 | be = class { |
| 1603 | constructor(t) { |
| 1604 | this._worker = t |
| 1605 | } |
| 1606 | provideRenameEdits(t, i, r, n) { |
| 1607 | let a = t.uri |
| 1608 | return this._worker(a) |
| 1609 | .then((o) => o.doRename(a.toString(), L(i), r)) |
| 1610 | .then((o) => Vn(o)) |
| 1611 | } |
| 1612 | } |
| 1613 | function Vn(e) { |
| 1614 | if (!e || !e.changes) return |
| 1615 | let t = [] |
| 1616 | for (let i in e.changes) { |
| 1617 | let r = l.Uri.parse(i) |
| 1618 | for (let n of e.changes[i]) |
| 1619 | t.push({ |
| 1620 | resource: r, |
| 1621 | versionId: void 0, |
| 1622 | textEdit: { range: C(n.range), text: n.newText }, |
| 1623 | }) |
| 1624 | } |
| 1625 | return { edits: t } |
| 1626 | } |
| 1627 | var $ = class { |
| 1628 | constructor(t) { |
| 1629 | this._worker = t |
| 1630 | } |
| 1631 | provideDocumentSymbols(t, i) { |
| 1632 | let r = t.uri |
| 1633 | return this._worker(r) |
| 1634 | .then((n) => n.findDocumentSymbols(r.toString())) |
| 1635 | .then((n) => { |
| 1636 | if (!!n) |
| 1637 | return n.map((a) => ({ |
| 1638 | name: a.name, |
| 1639 | detail: '', |
| 1640 | containerName: a.containerName, |
| 1641 | kind: Kn(a.kind), |
| 1642 | range: C(a.location.range), |
| 1643 | selectionRange: C(a.location.range), |
| 1644 | tags: [], |
| 1645 | })) |
| 1646 | }) |
| 1647 | } |
| 1648 | } |
| 1649 | function Kn(e) { |
| 1650 | let t = l.languages.SymbolKind |
| 1651 | switch (e) { |
| 1652 | case v.File: |
| 1653 | return t.Array |
| 1654 | case v.Module: |
| 1655 | return t.Module |
| 1656 | case v.Namespace: |
| 1657 | return t.Namespace |
| 1658 | case v.Package: |
| 1659 | return t.Package |
| 1660 | case v.Class: |
| 1661 | return t.Class |
| 1662 | case v.Method: |
| 1663 | return t.Method |
| 1664 | case v.Property: |
| 1665 | return t.Property |
| 1666 | case v.Field: |
| 1667 | return t.Field |
| 1668 | case v.Constructor: |
| 1669 | return t.Constructor |
| 1670 | case v.Enum: |
| 1671 | return t.Enum |
| 1672 | case v.Interface: |
| 1673 | return t.Interface |
| 1674 | case v.Function: |
| 1675 | return t.Function |
| 1676 | case v.Variable: |
| 1677 | return t.Variable |
| 1678 | case v.Constant: |
| 1679 | return t.Constant |
| 1680 | case v.String: |
| 1681 | return t.String |
| 1682 | case v.Number: |
| 1683 | return t.Number |
| 1684 | case v.Boolean: |
| 1685 | return t.Boolean |
| 1686 | case v.Array: |
| 1687 | return t.Array |
| 1688 | } |
| 1689 | return t.Function |
| 1690 | } |
| 1691 | var Ce = class { |
| 1692 | constructor(t) { |
| 1693 | this._worker = t |
| 1694 | } |
| 1695 | provideLinks(t, i) { |
| 1696 | let r = t.uri |
| 1697 | return this._worker(r) |
| 1698 | .then((n) => n.findDocumentLinks(r.toString())) |
| 1699 | .then((n) => { |
| 1700 | if (!!n) return { links: n.map((a) => ({ range: C(a.range), url: a.target })) } |
| 1701 | }) |
| 1702 | } |
| 1703 | }, |
| 1704 | G = class { |
| 1705 | constructor(t) { |
| 1706 | this._worker = t |
| 1707 | } |
| 1708 | provideDocumentFormattingEdits(t, i, r) { |
| 1709 | let n = t.uri |
| 1710 | return this._worker(n).then((a) => |
| 1711 | a.format(n.toString(), null, ln(i)).then((o) => { |
| 1712 | if (!(!o || o.length === 0)) return o.map(j) |
| 1713 | }) |
| 1714 | ) |
| 1715 | } |
| 1716 | }, |
| 1717 | Q = class { |
| 1718 | constructor(t) { |
| 1719 | this._worker = t |
| 1720 | } |
| 1721 | canFormatMultipleRanges = !1 |
| 1722 | provideDocumentRangeFormattingEdits(t, i, r, n) { |
| 1723 | let a = t.uri |
| 1724 | return this._worker(a).then((o) => |
| 1725 | o.format(a.toString(), we(i), ln(r)).then((u) => { |
| 1726 | if (!(!u || u.length === 0)) return u.map(j) |
| 1727 | }) |
| 1728 | ) |
| 1729 | } |
| 1730 | } |
| 1731 | function ln(e) { |
| 1732 | return { tabSize: e.tabSize, insertSpaces: e.insertSpaces } |
| 1733 | } |
| 1734 | var Z = class { |
| 1735 | constructor(t) { |
| 1736 | this._worker = t |
| 1737 | } |
| 1738 | provideDocumentColors(t, i) { |
| 1739 | let r = t.uri |
| 1740 | return this._worker(r) |
| 1741 | .then((n) => n.findDocumentColors(r.toString())) |
| 1742 | .then((n) => { |
| 1743 | if (!!n) return n.map((a) => ({ color: a.color, range: C(a.range) })) |
| 1744 | }) |
| 1745 | } |
| 1746 | provideColorPresentations(t, i, r) { |
| 1747 | let n = t.uri |
| 1748 | return this._worker(n) |
| 1749 | .then((a) => a.getColorPresentations(n.toString(), i.color, we(i.range))) |
| 1750 | .then((a) => { |
| 1751 | if (!!a) |
| 1752 | return a.map((o) => { |
| 1753 | let u = { label: o.label } |
| 1754 | return ( |
| 1755 | o.textEdit && (u.textEdit = j(o.textEdit)), |
| 1756 | o.additionalTextEdits && (u.additionalTextEdits = o.additionalTextEdits.map(j)), |
| 1757 | u |
| 1758 | ) |
| 1759 | }) |
| 1760 | }) |
| 1761 | } |
| 1762 | }, |
| 1763 | ee = class { |
| 1764 | constructor(t) { |
| 1765 | this._worker = t |
| 1766 | } |
| 1767 | provideFoldingRanges(t, i, r) { |
| 1768 | let n = t.uri |
| 1769 | return this._worker(n) |
| 1770 | .then((a) => a.getFoldingRanges(n.toString(), i)) |
| 1771 | .then((a) => { |
| 1772 | if (!!a) |
| 1773 | return a.map((o) => { |
| 1774 | let u = { start: o.startLine + 1, end: o.endLine + 1 } |
| 1775 | return typeof o.kind < 'u' && (u.kind = Hn(o.kind)), u |
| 1776 | }) |
| 1777 | }) |
| 1778 | } |
| 1779 | } |
| 1780 | function Hn(e) { |
| 1781 | switch (e) { |
| 1782 | case M.Comment: |
| 1783 | return l.languages.FoldingRangeKind.Comment |
| 1784 | case M.Imports: |
| 1785 | return l.languages.FoldingRangeKind.Imports |
| 1786 | case M.Region: |
| 1787 | return l.languages.FoldingRangeKind.Region |
| 1788 | } |
| 1789 | } |
| 1790 | var ne = class { |
| 1791 | constructor(t) { |
| 1792 | this._worker = t |
| 1793 | } |
| 1794 | provideSelectionRanges(t, i, r) { |
| 1795 | let n = t.uri |
| 1796 | return this._worker(n) |
| 1797 | .then((a) => a.getSelectionRanges(n.toString(), i.map(L))) |
| 1798 | .then((a) => { |
| 1799 | if (!!a) |
| 1800 | return a.map((o) => { |
| 1801 | let u = [] |
| 1802 | for (; o; ) u.push({ range: C(o.range) }), (o = o.parent) |
| 1803 | return u |
| 1804 | }) |
| 1805 | }) |
| 1806 | } |
| 1807 | } |
| 1808 | function de(e, t) { |
| 1809 | t === void 0 && (t = !1) |
| 1810 | var i = e.length, |
| 1811 | r = 0, |
| 1812 | n = '', |
| 1813 | a = 0, |
| 1814 | o = 16, |
| 1815 | u = 0, |
| 1816 | c = 0, |
| 1817 | h = 0, |
| 1818 | p = 0, |
| 1819 | f = 0 |
| 1820 | function b(d, w) { |
| 1821 | for (var x = 0, I = 0; x < d || !w; ) { |
| 1822 | var k = e.charCodeAt(r) |
| 1823 | if (k >= 48 && k <= 57) I = I * 16 + k - 48 |
| 1824 | else if (k >= 65 && k <= 70) I = I * 16 + k - 65 + 10 |
| 1825 | else if (k >= 97 && k <= 102) I = I * 16 + k - 97 + 10 |
| 1826 | else break |
| 1827 | r++, x++ |
| 1828 | } |
| 1829 | return x < d && (I = -1), I |
| 1830 | } |
| 1831 | function g(d) { |
| 1832 | ;(r = d), (n = ''), (a = 0), (o = 16), (f = 0) |
| 1833 | } |
| 1834 | function E() { |
| 1835 | var d = r |
| 1836 | if (e.charCodeAt(r) === 48) r++ |
| 1837 | else for (r++; r < e.length && U(e.charCodeAt(r)); ) r++ |
| 1838 | if (r < e.length && e.charCodeAt(r) === 46) |
| 1839 | if ((r++, r < e.length && U(e.charCodeAt(r)))) |
| 1840 | for (r++; r < e.length && U(e.charCodeAt(r)); ) r++ |
| 1841 | else return (f = 3), e.substring(d, r) |
| 1842 | var w = r |
| 1843 | if (r < e.length && (e.charCodeAt(r) === 69 || e.charCodeAt(r) === 101)) |
| 1844 | if ( |
| 1845 | (r++, |
| 1846 | ((r < e.length && e.charCodeAt(r) === 43) || e.charCodeAt(r) === 45) && r++, |
| 1847 | r < e.length && U(e.charCodeAt(r))) |
| 1848 | ) { |
| 1849 | for (r++; r < e.length && U(e.charCodeAt(r)); ) r++ |
| 1850 | w = r |
| 1851 | } else f = 3 |
| 1852 | return e.substring(d, w) |
| 1853 | } |
| 1854 | function R() { |
| 1855 | for (var d = '', w = r; ; ) { |
| 1856 | if (r >= i) { |
| 1857 | ;(d += e.substring(w, r)), (f = 2) |
| 1858 | break |
| 1859 | } |
| 1860 | var x = e.charCodeAt(r) |
| 1861 | if (x === 34) { |
| 1862 | ;(d += e.substring(w, r)), r++ |
| 1863 | break |
| 1864 | } |
| 1865 | if (x === 92) { |
| 1866 | if (((d += e.substring(w, r)), r++, r >= i)) { |
| 1867 | f = 2 |
| 1868 | break |
| 1869 | } |
| 1870 | var I = e.charCodeAt(r++) |
| 1871 | switch (I) { |
| 1872 | case 34: |
| 1873 | d += '"' |
| 1874 | break |
| 1875 | case 92: |
| 1876 | d += '\\' |
| 1877 | break |
| 1878 | case 47: |
| 1879 | d += '/' |
| 1880 | break |
| 1881 | case 98: |
| 1882 | d += '\b' |
| 1883 | break |
| 1884 | case 102: |
| 1885 | d += '\f' |
| 1886 | break |
| 1887 | case 110: |
| 1888 | d += ` |
| 1889 | ` |
| 1890 | break |
| 1891 | case 114: |
| 1892 | d += '\r' |
| 1893 | break |
| 1894 | case 116: |
| 1895 | d += ' ' |
| 1896 | break |
| 1897 | case 117: |
| 1898 | var k = b(4, !0) |
| 1899 | k >= 0 ? (d += String.fromCharCode(k)) : (f = 4) |
| 1900 | break |
| 1901 | default: |
| 1902 | f = 5 |
| 1903 | } |
| 1904 | w = r |
| 1905 | continue |
| 1906 | } |
| 1907 | if (x >= 0 && x <= 31) |
| 1908 | if (re(x)) { |
| 1909 | ;(d += e.substring(w, r)), (f = 2) |
| 1910 | break |
| 1911 | } else f = 6 |
| 1912 | r++ |
| 1913 | } |
| 1914 | return d |
| 1915 | } |
| 1916 | function V() { |
| 1917 | if (((n = ''), (f = 0), (a = r), (c = u), (p = h), r >= i)) return (a = i), (o = 17) |
| 1918 | var d = e.charCodeAt(r) |
| 1919 | if (Ie(d)) { |
| 1920 | do r++, (n += String.fromCharCode(d)), (d = e.charCodeAt(r)) |
| 1921 | while (Ie(d)) |
| 1922 | return (o = 15) |
| 1923 | } |
| 1924 | if (re(d)) |
| 1925 | return ( |
| 1926 | r++, |
| 1927 | (n += String.fromCharCode(d)), |
| 1928 | d === 13 && |
| 1929 | e.charCodeAt(r) === 10 && |
| 1930 | (r++, |
| 1931 | (n += ` |
| 1932 | `)), |
| 1933 | u++, |
| 1934 | (h = r), |
| 1935 | (o = 14) |
| 1936 | ) |
| 1937 | switch (d) { |
| 1938 | case 123: |
| 1939 | return r++, (o = 1) |
| 1940 | case 125: |
| 1941 | return r++, (o = 2) |
| 1942 | case 91: |
| 1943 | return r++, (o = 3) |
| 1944 | case 93: |
| 1945 | return r++, (o = 4) |
| 1946 | case 58: |
| 1947 | return r++, (o = 6) |
| 1948 | case 44: |
| 1949 | return r++, (o = 5) |
| 1950 | case 34: |
| 1951 | return r++, (n = R()), (o = 10) |
| 1952 | case 47: |
| 1953 | var w = r - 1 |
| 1954 | if (e.charCodeAt(r + 1) === 47) { |
| 1955 | for (r += 2; r < i && !re(e.charCodeAt(r)); ) r++ |
| 1956 | return (n = e.substring(w, r)), (o = 12) |
| 1957 | } |
| 1958 | if (e.charCodeAt(r + 1) === 42) { |
| 1959 | r += 2 |
| 1960 | for (var x = i - 1, I = !1; r < x; ) { |
| 1961 | var k = e.charCodeAt(r) |
| 1962 | if (k === 42 && e.charCodeAt(r + 1) === 47) { |
| 1963 | ;(r += 2), (I = !0) |
| 1964 | break |
| 1965 | } |
| 1966 | r++, re(k) && (k === 13 && e.charCodeAt(r) === 10 && r++, u++, (h = r)) |
| 1967 | } |
| 1968 | return I || (r++, (f = 1)), (n = e.substring(w, r)), (o = 13) |
| 1969 | } |
| 1970 | return (n += String.fromCharCode(d)), r++, (o = 16) |
| 1971 | case 45: |
| 1972 | if (((n += String.fromCharCode(d)), r++, r === i || !U(e.charCodeAt(r)))) |
| 1973 | return (o = 16) |
| 1974 | case 48: |
| 1975 | case 49: |
| 1976 | case 50: |
| 1977 | case 51: |
| 1978 | case 52: |
| 1979 | case 53: |
| 1980 | case 54: |
| 1981 | case 55: |
| 1982 | case 56: |
| 1983 | case 57: |
| 1984 | return (n += E()), (o = 11) |
| 1985 | default: |
| 1986 | for (; r < i && yn(d); ) r++, (d = e.charCodeAt(r)) |
| 1987 | if (a !== r) { |
| 1988 | switch (((n = e.substring(a, r)), n)) { |
| 1989 | case 'true': |
| 1990 | return (o = 8) |
| 1991 | case 'false': |
| 1992 | return (o = 9) |
| 1993 | case 'null': |
| 1994 | return (o = 7) |
| 1995 | } |
| 1996 | return (o = 16) |
| 1997 | } |
| 1998 | return (n += String.fromCharCode(d)), r++, (o = 16) |
| 1999 | } |
| 2000 | } |
| 2001 | function yn(d) { |
| 2002 | if (Ie(d) || re(d)) return !1 |
| 2003 | switch (d) { |
| 2004 | case 125: |
| 2005 | case 93: |
| 2006 | case 123: |
| 2007 | case 91: |
| 2008 | case 34: |
| 2009 | case 58: |
| 2010 | case 44: |
| 2011 | case 47: |
| 2012 | return !1 |
| 2013 | } |
| 2014 | return !0 |
| 2015 | } |
| 2016 | function kn() { |
| 2017 | var d |
| 2018 | do d = V() |
| 2019 | while (d >= 12 && d <= 15) |
| 2020 | return d |
| 2021 | } |
| 2022 | return { |
| 2023 | setPosition: g, |
| 2024 | getPosition: function () { |
| 2025 | return r |
| 2026 | }, |
| 2027 | scan: t ? kn : V, |
| 2028 | getToken: function () { |
| 2029 | return o |
| 2030 | }, |
| 2031 | getTokenValue: function () { |
| 2032 | return n |
| 2033 | }, |
| 2034 | getTokenOffset: function () { |
| 2035 | return a |
| 2036 | }, |
| 2037 | getTokenLength: function () { |
| 2038 | return r - a |
| 2039 | }, |
| 2040 | getTokenStartLine: function () { |
| 2041 | return c |
| 2042 | }, |
| 2043 | getTokenStartCharacter: function () { |
| 2044 | return a - p |
| 2045 | }, |
| 2046 | getTokenError: function () { |
| 2047 | return f |
| 2048 | }, |
| 2049 | } |
| 2050 | } |
| 2051 | function Ie(e) { |
| 2052 | return ( |
| 2053 | e === 32 || |
| 2054 | e === 9 || |
| 2055 | e === 11 || |
| 2056 | e === 12 || |
| 2057 | e === 160 || |
| 2058 | e === 5760 || |
| 2059 | (e >= 8192 && e <= 8203) || |
| 2060 | e === 8239 || |
| 2061 | e === 8287 || |
| 2062 | e === 12288 || |
| 2063 | e === 65279 |
| 2064 | ) |
| 2065 | } |
| 2066 | function re(e) { |
| 2067 | return e === 10 || e === 13 || e === 8232 || e === 8233 |
| 2068 | } |
| 2069 | function U(e) { |
| 2070 | return e >= 48 && e <= 57 |
| 2071 | } |
| 2072 | var fn |
| 2073 | ;(function (e) { |
| 2074 | e.DEFAULT = { allowTrailingComma: !1 } |
| 2075 | })(fn || (fn = {})) |
| 2076 | var dn = de |
| 2077 | function hn(e) { |
| 2078 | return { getInitialState: () => new W(null, null, !1, null), tokenize: (t, i) => ur(e, t, i) } |
| 2079 | } |
| 2080 | var gn = 'delimiter.bracket.json', |
| 2081 | pn = 'delimiter.array.json', |
| 2082 | Zn = 'delimiter.colon.json', |
| 2083 | er = 'delimiter.comma.json', |
| 2084 | nr = 'keyword.json', |
| 2085 | rr = 'keyword.json', |
| 2086 | tr = 'string.value.json', |
| 2087 | ir = 'number.json', |
| 2088 | ar = 'string.key.json', |
| 2089 | or = 'comment.block.json', |
| 2090 | sr = 'comment.line.json' |
| 2091 | var P = class { |
| 2092 | constructor(t, i) { |
| 2093 | this.parent = t |
| 2094 | this.type = i |
| 2095 | } |
| 2096 | static pop(t) { |
| 2097 | return t ? t.parent : null |
| 2098 | } |
| 2099 | static push(t, i) { |
| 2100 | return new P(t, i) |
| 2101 | } |
| 2102 | static equals(t, i) { |
| 2103 | if (!t && !i) return !0 |
| 2104 | if (!t || !i) return !1 |
| 2105 | for (; t && i; ) { |
| 2106 | if (t === i) return !0 |
| 2107 | if (t.type !== i.type) return !1 |
| 2108 | ;(t = t.parent), (i = i.parent) |
| 2109 | } |
| 2110 | return !0 |
| 2111 | } |
| 2112 | }, |
| 2113 | W = class { |
| 2114 | _state |
| 2115 | scanError |
| 2116 | lastWasColon |
| 2117 | parents |
| 2118 | constructor(t, i, r, n) { |
| 2119 | ;(this._state = t), (this.scanError = i), (this.lastWasColon = r), (this.parents = n) |
| 2120 | } |
| 2121 | clone() { |
| 2122 | return new W(this._state, this.scanError, this.lastWasColon, this.parents) |
| 2123 | } |
| 2124 | equals(t) { |
| 2125 | return t === this |
| 2126 | ? !0 |
| 2127 | : !t || !(t instanceof W) |
| 2128 | ? !1 |
| 2129 | : this.scanError === t.scanError && |
| 2130 | this.lastWasColon === t.lastWasColon && |
| 2131 | P.equals(this.parents, t.parents) |
| 2132 | } |
| 2133 | getStateData() { |
| 2134 | return this._state |
| 2135 | } |
| 2136 | setStateData(t) { |
| 2137 | this._state = t |
| 2138 | } |
| 2139 | } |
| 2140 | function ur(e, t, i, r = 0) { |
| 2141 | let n = 0, |
| 2142 | a = !1 |
| 2143 | switch (i.scanError) { |
| 2144 | case 2: |
| 2145 | ;(t = '"' + t), (n = 1) |
| 2146 | break |
| 2147 | case 1: |
| 2148 | ;(t = '/*' + t), (n = 2) |
| 2149 | break |
| 2150 | } |
| 2151 | let o = dn(t), |
| 2152 | u = i.lastWasColon, |
| 2153 | c = i.parents, |
| 2154 | h = { tokens: [], endState: i.clone() } |
| 2155 | for (;;) { |
| 2156 | let p = r + o.getPosition(), |
| 2157 | f = '', |
| 2158 | b = o.scan() |
| 2159 | if (b === 17) break |
| 2160 | if (p === r + o.getPosition()) |
| 2161 | throw new Error( |
| 2162 | 'Scanner did not advance, next 3 characters are: ' + t.substr(o.getPosition(), 3) |
| 2163 | ) |
| 2164 | switch ((a && (p -= n), (a = n > 0), b)) { |
| 2165 | case 1: |
| 2166 | ;(c = P.push(c, 0)), (f = gn), (u = !1) |
| 2167 | break |
| 2168 | case 2: |
| 2169 | ;(c = P.pop(c)), (f = gn), (u = !1) |
| 2170 | break |
| 2171 | case 3: |
| 2172 | ;(c = P.push(c, 1)), (f = pn), (u = !1) |
| 2173 | break |
| 2174 | case 4: |
| 2175 | ;(c = P.pop(c)), (f = pn), (u = !1) |
| 2176 | break |
| 2177 | case 6: |
| 2178 | ;(f = Zn), (u = !0) |
| 2179 | break |
| 2180 | case 5: |
| 2181 | ;(f = er), (u = !1) |
| 2182 | break |
| 2183 | case 8: |
| 2184 | case 9: |
| 2185 | ;(f = nr), (u = !1) |
| 2186 | break |
| 2187 | case 7: |
| 2188 | ;(f = rr), (u = !1) |
| 2189 | break |
| 2190 | case 10: |
| 2191 | let E = (c ? c.type : 0) === 1 |
| 2192 | ;(f = u || E ? tr : ar), (u = !1) |
| 2193 | break |
| 2194 | case 11: |
| 2195 | ;(f = ir), (u = !1) |
| 2196 | break |
| 2197 | } |
| 2198 | if (e) |
| 2199 | switch (b) { |
| 2200 | case 12: |
| 2201 | f = sr |
| 2202 | break |
| 2203 | case 13: |
| 2204 | f = or |
| 2205 | break |
| 2206 | } |
| 2207 | ;(h.endState = new W(i.getStateData(), o.getTokenError(), u, c)), |
| 2208 | h.tokens.push({ startIndex: p, scopes: f }) |
| 2209 | } |
| 2210 | return h |
| 2211 | } |
| 2212 | var xe = class extends q { |
| 2213 | constructor(t, i, r) { |
| 2214 | super(t, i, r.onDidChange), |
| 2215 | this._disposables.push( |
| 2216 | l.editor.onWillDisposeModel((n) => { |
| 2217 | this._resetSchema(n.uri) |
| 2218 | }) |
| 2219 | ), |
| 2220 | this._disposables.push( |
| 2221 | l.editor.onDidChangeModelLanguage((n) => { |
| 2222 | this._resetSchema(n.model.uri) |
| 2223 | }) |
| 2224 | ) |
| 2225 | } |
| 2226 | _resetSchema(t) { |
| 2227 | this._worker().then((i) => { |
| 2228 | i.resetSchema(t.toString()) |
| 2229 | }) |
| 2230 | } |
| 2231 | } |
| 2232 | function cr(e) { |
| 2233 | let t = [], |
| 2234 | i = [], |
| 2235 | r = new D(e) |
| 2236 | t.push(r) |
| 2237 | let n = (...u) => r.getLanguageServiceWorker(...u) |
| 2238 | function a() { |
| 2239 | let { languageId: u, modeConfiguration: c } = e |
| 2240 | vn(i), |
| 2241 | c.documentFormattingEdits && |
| 2242 | i.push(l.languages.registerDocumentFormattingEditProvider(u, new G(n))), |
| 2243 | c.documentRangeFormattingEdits && |
| 2244 | i.push(l.languages.registerDocumentRangeFormattingEditProvider(u, new Q(n))), |
| 2245 | c.completionItems && |
| 2246 | i.push(l.languages.registerCompletionItemProvider(u, new X(n, [' ', ':', '"']))), |
| 2247 | c.hovers && i.push(l.languages.registerHoverProvider(u, new Y(n))), |
| 2248 | c.documentSymbols && i.push(l.languages.registerDocumentSymbolProvider(u, new $(n))), |
| 2249 | c.tokens && i.push(l.languages.setTokensProvider(u, hn(!0))), |
| 2250 | c.colors && i.push(l.languages.registerColorProvider(u, new Z(n))), |
| 2251 | c.foldingRanges && i.push(l.languages.registerFoldingRangeProvider(u, new ee(n))), |
| 2252 | c.diagnostics && i.push(new xe(u, n, e)), |
| 2253 | c.selectionRanges && i.push(l.languages.registerSelectionRangeProvider(u, new ne(n))) |
| 2254 | } |
| 2255 | a(), t.push(l.languages.setLanguageConfiguration(e.languageId, lr)) |
| 2256 | let o = e.modeConfiguration |
| 2257 | return ( |
| 2258 | e.onDidChange((u) => { |
| 2259 | u.modeConfiguration !== o && ((o = u.modeConfiguration), a()) |
| 2260 | }), |
| 2261 | t.push(mn(i)), |
| 2262 | mn(t) |
| 2263 | ) |
| 2264 | } |
| 2265 | function mn(e) { |
| 2266 | return { dispose: () => vn(e) } |
| 2267 | } |
| 2268 | function vn(e) { |
| 2269 | for (; e.length; ) e.pop().dispose() |
| 2270 | } |
| 2271 | var lr = { |
| 2272 | wordPattern: /(-?\d*\.\d\w*)|([^\[\{\]\}\:\"\,\s]+)/g, |
| 2273 | comments: { lineComment: '//', blockComment: ['/*', '*/'] }, |
| 2274 | brackets: [ |
| 2275 | ['{', '}'], |
| 2276 | ['[', ']'], |
| 2277 | ], |
| 2278 | autoClosingPairs: [ |
| 2279 | { open: '{', close: '}', notIn: ['string'] }, |
| 2280 | { open: '[', close: ']', notIn: ['string'] }, |
| 2281 | { open: '"', close: '"', notIn: ['string'] }, |
| 2282 | ], |
| 2283 | } |
| 2284 | return Pn(fr) |
| 2285 | })() |
| 2286 | return moduleExports |
| 2287 | }) |