mirror of
https://github.com/neocities/neocities.git
synced 2025-04-25 09:42:36 +02:00
17047 lines
No EOL
597 KiB
JavaScript
17047 lines
No EOL
597 KiB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
module.exports = factory();
|
|
else if(typeof define === 'function' && define.amd)
|
|
define([], factory);
|
|
else {
|
|
var a = factory();
|
|
for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
|
|
}
|
|
})(this, () => {
|
|
return /******/ (() => { // webpackBootstrap
|
|
/******/ var __webpack_modules__ = ({
|
|
|
|
/***/ 6093:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
/* provided dependency */ var process = __webpack_require__(9907);
|
|
/* provided dependency */ var console = __webpack_require__(4364);
|
|
// Currently in sync with Node.js lib/assert.js
|
|
// https://github.com/nodejs/node/commit/2a51ae424a513ec9a6aa3466baa0cc1d55dd4f3b
|
|
// Originally from narwhal.js (http://narwhaljs.org)
|
|
// Copyright (c) 2009 Thomas Robinson <280north.com>
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the 'Software'), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
|
|
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var _require = __webpack_require__(1342),
|
|
_require$codes = _require.codes,
|
|
ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT,
|
|
ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
|
|
ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE,
|
|
ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE,
|
|
ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
|
|
|
|
var AssertionError = __webpack_require__(9801);
|
|
|
|
var _require2 = __webpack_require__(6827),
|
|
inspect = _require2.inspect;
|
|
|
|
var _require$types = (__webpack_require__(6827).types),
|
|
isPromise = _require$types.isPromise,
|
|
isRegExp = _require$types.isRegExp;
|
|
|
|
var objectAssign = Object.assign ? Object.assign : (__webpack_require__(3046).assign);
|
|
var objectIs = Object.is ? Object.is : __webpack_require__(5968);
|
|
var errorCache = new Map();
|
|
var isDeepEqual;
|
|
var isDeepStrictEqual;
|
|
var parseExpressionAt;
|
|
var findNodeAround;
|
|
var decoder;
|
|
|
|
function lazyLoadComparison() {
|
|
var comparison = __webpack_require__(5656);
|
|
|
|
isDeepEqual = comparison.isDeepEqual;
|
|
isDeepStrictEqual = comparison.isDeepStrictEqual;
|
|
} // Escape control characters but not \n and \t to keep the line breaks and
|
|
// indentation intact.
|
|
// eslint-disable-next-line no-control-regex
|
|
|
|
|
|
var escapeSequencesRegExp = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
|
|
var meta = (/* unused pure expression or super */ null && (["\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005", "\\u0006", "\\u0007", '\\b', '', '', "\\u000b", '\\f', '', "\\u000e", "\\u000f", "\\u0010", "\\u0011", "\\u0012", "\\u0013", "\\u0014", "\\u0015", "\\u0016", "\\u0017", "\\u0018", "\\u0019", "\\u001a", "\\u001b", "\\u001c", "\\u001d", "\\u001e", "\\u001f"]));
|
|
|
|
var escapeFn = function escapeFn(str) {
|
|
return meta[str.charCodeAt(0)];
|
|
};
|
|
|
|
var warned = false; // The assert module provides functions that throw
|
|
// AssertionError's when particular conditions are not met. The
|
|
// assert module must conform to the following interface.
|
|
|
|
var assert = module.exports = ok;
|
|
var NO_EXCEPTION_SENTINEL = {}; // All of the following functions must throw an AssertionError
|
|
// when a corresponding condition is not met, with a message that
|
|
// may be undefined if not provided. All assertion methods provide
|
|
// both the actual and expected values to the assertion error for
|
|
// display purposes.
|
|
|
|
function innerFail(obj) {
|
|
if (obj.message instanceof Error) throw obj.message;
|
|
throw new AssertionError(obj);
|
|
}
|
|
|
|
function fail(actual, expected, message, operator, stackStartFn) {
|
|
var argsLen = arguments.length;
|
|
var internalMessage;
|
|
|
|
if (argsLen === 0) {
|
|
internalMessage = 'Failed';
|
|
} else if (argsLen === 1) {
|
|
message = actual;
|
|
actual = undefined;
|
|
} else {
|
|
if (warned === false) {
|
|
warned = true;
|
|
var warn = process.emitWarning ? process.emitWarning : console.warn.bind(console);
|
|
warn('assert.fail() with more than one argument is deprecated. ' + 'Please use assert.strictEqual() instead or only pass a message.', 'DeprecationWarning', 'DEP0094');
|
|
}
|
|
|
|
if (argsLen === 2) operator = '!=';
|
|
}
|
|
|
|
if (message instanceof Error) throw message;
|
|
var errArgs = {
|
|
actual: actual,
|
|
expected: expected,
|
|
operator: operator === undefined ? 'fail' : operator,
|
|
stackStartFn: stackStartFn || fail
|
|
};
|
|
|
|
if (message !== undefined) {
|
|
errArgs.message = message;
|
|
}
|
|
|
|
var err = new AssertionError(errArgs);
|
|
|
|
if (internalMessage) {
|
|
err.message = internalMessage;
|
|
err.generatedMessage = true;
|
|
}
|
|
|
|
throw err;
|
|
}
|
|
|
|
assert.fail = fail; // The AssertionError is defined in internal/error.
|
|
|
|
assert.AssertionError = AssertionError;
|
|
|
|
function innerOk(fn, argLen, value, message) {
|
|
if (!value) {
|
|
var generatedMessage = false;
|
|
|
|
if (argLen === 0) {
|
|
generatedMessage = true;
|
|
message = 'No value argument passed to `assert.ok()`';
|
|
} else if (message instanceof Error) {
|
|
throw message;
|
|
}
|
|
|
|
var err = new AssertionError({
|
|
actual: value,
|
|
expected: true,
|
|
message: message,
|
|
operator: '==',
|
|
stackStartFn: fn
|
|
});
|
|
err.generatedMessage = generatedMessage;
|
|
throw err;
|
|
}
|
|
} // Pure assertion tests whether a value is truthy, as determined
|
|
// by !!value.
|
|
|
|
|
|
function ok() {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
innerOk.apply(void 0, [ok, args.length].concat(args));
|
|
}
|
|
|
|
assert.ok = ok; // The equality assertion tests shallow, coercive equality with ==.
|
|
|
|
/* eslint-disable no-restricted-properties */
|
|
|
|
assert.equal = function equal(actual, expected, message) {
|
|
if (arguments.length < 2) {
|
|
throw new ERR_MISSING_ARGS('actual', 'expected');
|
|
} // eslint-disable-next-line eqeqeq
|
|
|
|
|
|
if (actual != expected) {
|
|
innerFail({
|
|
actual: actual,
|
|
expected: expected,
|
|
message: message,
|
|
operator: '==',
|
|
stackStartFn: equal
|
|
});
|
|
}
|
|
}; // The non-equality assertion tests for whether two objects are not
|
|
// equal with !=.
|
|
|
|
|
|
assert.notEqual = function notEqual(actual, expected, message) {
|
|
if (arguments.length < 2) {
|
|
throw new ERR_MISSING_ARGS('actual', 'expected');
|
|
} // eslint-disable-next-line eqeqeq
|
|
|
|
|
|
if (actual == expected) {
|
|
innerFail({
|
|
actual: actual,
|
|
expected: expected,
|
|
message: message,
|
|
operator: '!=',
|
|
stackStartFn: notEqual
|
|
});
|
|
}
|
|
}; // The equivalence assertion tests a deep equality relation.
|
|
|
|
|
|
assert.deepEqual = function deepEqual(actual, expected, message) {
|
|
if (arguments.length < 2) {
|
|
throw new ERR_MISSING_ARGS('actual', 'expected');
|
|
}
|
|
|
|
if (isDeepEqual === undefined) lazyLoadComparison();
|
|
|
|
if (!isDeepEqual(actual, expected)) {
|
|
innerFail({
|
|
actual: actual,
|
|
expected: expected,
|
|
message: message,
|
|
operator: 'deepEqual',
|
|
stackStartFn: deepEqual
|
|
});
|
|
}
|
|
}; // The non-equivalence assertion tests for any deep inequality.
|
|
|
|
|
|
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
|
|
if (arguments.length < 2) {
|
|
throw new ERR_MISSING_ARGS('actual', 'expected');
|
|
}
|
|
|
|
if (isDeepEqual === undefined) lazyLoadComparison();
|
|
|
|
if (isDeepEqual(actual, expected)) {
|
|
innerFail({
|
|
actual: actual,
|
|
expected: expected,
|
|
message: message,
|
|
operator: 'notDeepEqual',
|
|
stackStartFn: notDeepEqual
|
|
});
|
|
}
|
|
};
|
|
/* eslint-enable */
|
|
|
|
|
|
assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
|
|
if (arguments.length < 2) {
|
|
throw new ERR_MISSING_ARGS('actual', 'expected');
|
|
}
|
|
|
|
if (isDeepEqual === undefined) lazyLoadComparison();
|
|
|
|
if (!isDeepStrictEqual(actual, expected)) {
|
|
innerFail({
|
|
actual: actual,
|
|
expected: expected,
|
|
message: message,
|
|
operator: 'deepStrictEqual',
|
|
stackStartFn: deepStrictEqual
|
|
});
|
|
}
|
|
};
|
|
|
|
assert.notDeepStrictEqual = notDeepStrictEqual;
|
|
|
|
function notDeepStrictEqual(actual, expected, message) {
|
|
if (arguments.length < 2) {
|
|
throw new ERR_MISSING_ARGS('actual', 'expected');
|
|
}
|
|
|
|
if (isDeepEqual === undefined) lazyLoadComparison();
|
|
|
|
if (isDeepStrictEqual(actual, expected)) {
|
|
innerFail({
|
|
actual: actual,
|
|
expected: expected,
|
|
message: message,
|
|
operator: 'notDeepStrictEqual',
|
|
stackStartFn: notDeepStrictEqual
|
|
});
|
|
}
|
|
}
|
|
|
|
assert.strictEqual = function strictEqual(actual, expected, message) {
|
|
if (arguments.length < 2) {
|
|
throw new ERR_MISSING_ARGS('actual', 'expected');
|
|
}
|
|
|
|
if (!objectIs(actual, expected)) {
|
|
innerFail({
|
|
actual: actual,
|
|
expected: expected,
|
|
message: message,
|
|
operator: 'strictEqual',
|
|
stackStartFn: strictEqual
|
|
});
|
|
}
|
|
};
|
|
|
|
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
|
|
if (arguments.length < 2) {
|
|
throw new ERR_MISSING_ARGS('actual', 'expected');
|
|
}
|
|
|
|
if (objectIs(actual, expected)) {
|
|
innerFail({
|
|
actual: actual,
|
|
expected: expected,
|
|
message: message,
|
|
operator: 'notStrictEqual',
|
|
stackStartFn: notStrictEqual
|
|
});
|
|
}
|
|
};
|
|
|
|
var Comparison = function Comparison(obj, keys, actual) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, Comparison);
|
|
|
|
keys.forEach(function (key) {
|
|
if (key in obj) {
|
|
if (actual !== undefined && typeof actual[key] === 'string' && isRegExp(obj[key]) && obj[key].test(actual[key])) {
|
|
_this[key] = actual[key];
|
|
} else {
|
|
_this[key] = obj[key];
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
function compareExceptionKey(actual, expected, key, message, keys, fn) {
|
|
if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
|
|
if (!message) {
|
|
// Create placeholder objects to create a nice output.
|
|
var a = new Comparison(actual, keys);
|
|
var b = new Comparison(expected, keys, actual);
|
|
var err = new AssertionError({
|
|
actual: a,
|
|
expected: b,
|
|
operator: 'deepStrictEqual',
|
|
stackStartFn: fn
|
|
});
|
|
err.actual = actual;
|
|
err.expected = expected;
|
|
err.operator = fn.name;
|
|
throw err;
|
|
}
|
|
|
|
innerFail({
|
|
actual: actual,
|
|
expected: expected,
|
|
message: message,
|
|
operator: fn.name,
|
|
stackStartFn: fn
|
|
});
|
|
}
|
|
}
|
|
|
|
function expectedException(actual, expected, msg, fn) {
|
|
if (typeof expected !== 'function') {
|
|
if (isRegExp(expected)) return expected.test(actual); // assert.doesNotThrow does not accept objects.
|
|
|
|
if (arguments.length === 2) {
|
|
throw new ERR_INVALID_ARG_TYPE('expected', ['Function', 'RegExp'], expected);
|
|
} // Handle primitives properly.
|
|
|
|
|
|
if (_typeof(actual) !== 'object' || actual === null) {
|
|
var err = new AssertionError({
|
|
actual: actual,
|
|
expected: expected,
|
|
message: msg,
|
|
operator: 'deepStrictEqual',
|
|
stackStartFn: fn
|
|
});
|
|
err.operator = fn.name;
|
|
throw err;
|
|
}
|
|
|
|
var keys = Object.keys(expected); // Special handle errors to make sure the name and the message are compared
|
|
// as well.
|
|
|
|
if (expected instanceof Error) {
|
|
keys.push('name', 'message');
|
|
} else if (keys.length === 0) {
|
|
throw new ERR_INVALID_ARG_VALUE('error', expected, 'may not be an empty object');
|
|
}
|
|
|
|
if (isDeepEqual === undefined) lazyLoadComparison();
|
|
keys.forEach(function (key) {
|
|
if (typeof actual[key] === 'string' && isRegExp(expected[key]) && expected[key].test(actual[key])) {
|
|
return;
|
|
}
|
|
|
|
compareExceptionKey(actual, expected, key, msg, keys, fn);
|
|
});
|
|
return true;
|
|
} // Guard instanceof against arrow functions as they don't have a prototype.
|
|
|
|
|
|
if (expected.prototype !== undefined && actual instanceof expected) {
|
|
return true;
|
|
}
|
|
|
|
if (Error.isPrototypeOf(expected)) {
|
|
return false;
|
|
}
|
|
|
|
return expected.call({}, actual) === true;
|
|
}
|
|
|
|
function getActual(fn) {
|
|
if (typeof fn !== 'function') {
|
|
throw new ERR_INVALID_ARG_TYPE('fn', 'Function', fn);
|
|
}
|
|
|
|
try {
|
|
fn();
|
|
} catch (e) {
|
|
return e;
|
|
}
|
|
|
|
return NO_EXCEPTION_SENTINEL;
|
|
}
|
|
|
|
function checkIsPromise(obj) {
|
|
// Accept native ES6 promises and promises that are implemented in a similar
|
|
// way. Do not accept thenables that use a function as `obj` and that have no
|
|
// `catch` handler.
|
|
// TODO: thenables are checked up until they have the correct methods,
|
|
// but according to documentation, the `then` method should receive
|
|
// the `fulfill` and `reject` arguments as well or it may be never resolved.
|
|
return isPromise(obj) || obj !== null && _typeof(obj) === 'object' && typeof obj.then === 'function' && typeof obj.catch === 'function';
|
|
}
|
|
|
|
function waitForActual(promiseFn) {
|
|
return Promise.resolve().then(function () {
|
|
var resultPromise;
|
|
|
|
if (typeof promiseFn === 'function') {
|
|
// Return a rejected promise if `promiseFn` throws synchronously.
|
|
resultPromise = promiseFn(); // Fail in case no promise is returned.
|
|
|
|
if (!checkIsPromise(resultPromise)) {
|
|
throw new ERR_INVALID_RETURN_VALUE('instance of Promise', 'promiseFn', resultPromise);
|
|
}
|
|
} else if (checkIsPromise(promiseFn)) {
|
|
resultPromise = promiseFn;
|
|
} else {
|
|
throw new ERR_INVALID_ARG_TYPE('promiseFn', ['Function', 'Promise'], promiseFn);
|
|
}
|
|
|
|
return Promise.resolve().then(function () {
|
|
return resultPromise;
|
|
}).then(function () {
|
|
return NO_EXCEPTION_SENTINEL;
|
|
}).catch(function (e) {
|
|
return e;
|
|
});
|
|
});
|
|
}
|
|
|
|
function expectsError(stackStartFn, actual, error, message) {
|
|
if (typeof error === 'string') {
|
|
if (arguments.length === 4) {
|
|
throw new ERR_INVALID_ARG_TYPE('error', ['Object', 'Error', 'Function', 'RegExp'], error);
|
|
}
|
|
|
|
if (_typeof(actual) === 'object' && actual !== null) {
|
|
if (actual.message === error) {
|
|
throw new ERR_AMBIGUOUS_ARGUMENT('error/message', "The error message \"".concat(actual.message, "\" is identical to the message."));
|
|
}
|
|
} else if (actual === error) {
|
|
throw new ERR_AMBIGUOUS_ARGUMENT('error/message', "The error \"".concat(actual, "\" is identical to the message."));
|
|
}
|
|
|
|
message = error;
|
|
error = undefined;
|
|
} else if (error != null && _typeof(error) !== 'object' && typeof error !== 'function') {
|
|
throw new ERR_INVALID_ARG_TYPE('error', ['Object', 'Error', 'Function', 'RegExp'], error);
|
|
}
|
|
|
|
if (actual === NO_EXCEPTION_SENTINEL) {
|
|
var details = '';
|
|
|
|
if (error && error.name) {
|
|
details += " (".concat(error.name, ")");
|
|
}
|
|
|
|
details += message ? ": ".concat(message) : '.';
|
|
var fnType = stackStartFn.name === 'rejects' ? 'rejection' : 'exception';
|
|
innerFail({
|
|
actual: undefined,
|
|
expected: error,
|
|
operator: stackStartFn.name,
|
|
message: "Missing expected ".concat(fnType).concat(details),
|
|
stackStartFn: stackStartFn
|
|
});
|
|
}
|
|
|
|
if (error && !expectedException(actual, error, message, stackStartFn)) {
|
|
throw actual;
|
|
}
|
|
}
|
|
|
|
function expectsNoError(stackStartFn, actual, error, message) {
|
|
if (actual === NO_EXCEPTION_SENTINEL) return;
|
|
|
|
if (typeof error === 'string') {
|
|
message = error;
|
|
error = undefined;
|
|
}
|
|
|
|
if (!error || expectedException(actual, error)) {
|
|
var details = message ? ": ".concat(message) : '.';
|
|
var fnType = stackStartFn.name === 'doesNotReject' ? 'rejection' : 'exception';
|
|
innerFail({
|
|
actual: actual,
|
|
expected: error,
|
|
operator: stackStartFn.name,
|
|
message: "Got unwanted ".concat(fnType).concat(details, "\n") + "Actual message: \"".concat(actual && actual.message, "\""),
|
|
stackStartFn: stackStartFn
|
|
});
|
|
}
|
|
|
|
throw actual;
|
|
}
|
|
|
|
assert.throws = function throws(promiseFn) {
|
|
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
|
args[_key2 - 1] = arguments[_key2];
|
|
}
|
|
|
|
expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args));
|
|
};
|
|
|
|
assert.rejects = function rejects(promiseFn) {
|
|
for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
|
|
args[_key3 - 1] = arguments[_key3];
|
|
}
|
|
|
|
return waitForActual(promiseFn).then(function (result) {
|
|
return expectsError.apply(void 0, [rejects, result].concat(args));
|
|
});
|
|
};
|
|
|
|
assert.doesNotThrow = function doesNotThrow(fn) {
|
|
for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
|
|
args[_key4 - 1] = arguments[_key4];
|
|
}
|
|
|
|
expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args));
|
|
};
|
|
|
|
assert.doesNotReject = function doesNotReject(fn) {
|
|
for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
|
|
args[_key5 - 1] = arguments[_key5];
|
|
}
|
|
|
|
return waitForActual(fn).then(function (result) {
|
|
return expectsNoError.apply(void 0, [doesNotReject, result].concat(args));
|
|
});
|
|
};
|
|
|
|
assert.ifError = function ifError(err) {
|
|
if (err !== null && err !== undefined) {
|
|
var message = 'ifError got unwanted exception: ';
|
|
|
|
if (_typeof(err) === 'object' && typeof err.message === 'string') {
|
|
if (err.message.length === 0 && err.constructor) {
|
|
message += err.constructor.name;
|
|
} else {
|
|
message += err.message;
|
|
}
|
|
} else {
|
|
message += inspect(err);
|
|
}
|
|
|
|
var newErr = new AssertionError({
|
|
actual: err,
|
|
expected: null,
|
|
operator: 'ifError',
|
|
message: message,
|
|
stackStartFn: ifError
|
|
}); // Make sure we actually have a stack trace!
|
|
|
|
var origStack = err.stack;
|
|
|
|
if (typeof origStack === 'string') {
|
|
// This will remove any duplicated frames from the error frames taken
|
|
// from within `ifError` and add the original error frames to the newly
|
|
// created ones.
|
|
var tmp2 = origStack.split('\n');
|
|
tmp2.shift(); // Filter all frames existing in err.stack.
|
|
|
|
var tmp1 = newErr.stack.split('\n');
|
|
|
|
for (var i = 0; i < tmp2.length; i++) {
|
|
// Find the first occurrence of the frame.
|
|
var pos = tmp1.indexOf(tmp2[i]);
|
|
|
|
if (pos !== -1) {
|
|
// Only keep new frames.
|
|
tmp1 = tmp1.slice(0, pos);
|
|
break;
|
|
}
|
|
}
|
|
|
|
newErr.stack = "".concat(tmp1.join('\n'), "\n").concat(tmp2.join('\n'));
|
|
}
|
|
|
|
throw newErr;
|
|
}
|
|
}; // Expose a strict only variant of assert
|
|
|
|
|
|
function strict() {
|
|
for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
|
|
args[_key6] = arguments[_key6];
|
|
}
|
|
|
|
innerOk.apply(void 0, [strict, args.length].concat(args));
|
|
}
|
|
|
|
assert.strict = objectAssign(strict, assert, {
|
|
equal: assert.strictEqual,
|
|
deepEqual: assert.deepStrictEqual,
|
|
notEqual: assert.notStrictEqual,
|
|
notDeepEqual: assert.notDeepStrictEqual
|
|
});
|
|
assert.strict.strict = assert.strict;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9801:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
/* provided dependency */ var process = __webpack_require__(9907);
|
|
// Currently in sync with Node.js lib/internal/assert/assertion_error.js
|
|
// https://github.com/nodejs/node/commit/0817840f775032169ddd70c85ac059f18ffcc81c
|
|
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
var _require = __webpack_require__(6827),
|
|
inspect = _require.inspect;
|
|
|
|
var _require2 = __webpack_require__(1342),
|
|
ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE; // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
|
|
|
|
|
|
function endsWith(str, search, this_len) {
|
|
if (this_len === undefined || this_len > str.length) {
|
|
this_len = str.length;
|
|
}
|
|
|
|
return str.substring(this_len - search.length, this_len) === search;
|
|
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat
|
|
|
|
|
|
function repeat(str, count) {
|
|
count = Math.floor(count);
|
|
if (str.length == 0 || count == 0) return '';
|
|
var maxCount = str.length * count;
|
|
count = Math.floor(Math.log(count) / Math.log(2));
|
|
|
|
while (count) {
|
|
str += str;
|
|
count--;
|
|
}
|
|
|
|
str += str.substring(0, maxCount - str.length);
|
|
return str;
|
|
}
|
|
|
|
var blue = '';
|
|
var green = '';
|
|
var red = '';
|
|
var white = '';
|
|
var kReadableOperator = {
|
|
deepStrictEqual: 'Expected values to be strictly deep-equal:',
|
|
strictEqual: 'Expected values to be strictly equal:',
|
|
strictEqualObject: 'Expected "actual" to be reference-equal to "expected":',
|
|
deepEqual: 'Expected values to be loosely deep-equal:',
|
|
equal: 'Expected values to be loosely equal:',
|
|
notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
|
|
notStrictEqual: 'Expected "actual" to be strictly unequal to:',
|
|
notStrictEqualObject: 'Expected "actual" not to be reference-equal to "expected":',
|
|
notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
|
|
notEqual: 'Expected "actual" to be loosely unequal to:',
|
|
notIdentical: 'Values identical but not reference-equal:'
|
|
}; // Comparing short primitives should just show === / !== instead of using the
|
|
// diff.
|
|
|
|
var kMaxShortLength = 10;
|
|
|
|
function copyError(source) {
|
|
var keys = Object.keys(source);
|
|
var target = Object.create(Object.getPrototypeOf(source));
|
|
keys.forEach(function (key) {
|
|
target[key] = source[key];
|
|
});
|
|
Object.defineProperty(target, 'message', {
|
|
value: source.message
|
|
});
|
|
return target;
|
|
}
|
|
|
|
function inspectValue(val) {
|
|
// The util.inspect default values could be changed. This makes sure the
|
|
// error messages contain the necessary information nevertheless.
|
|
return inspect(val, {
|
|
compact: false,
|
|
customInspect: false,
|
|
depth: 1000,
|
|
maxArrayLength: Infinity,
|
|
// Assert compares only enumerable properties (with a few exceptions).
|
|
showHidden: false,
|
|
// Having a long line as error is better than wrapping the line for
|
|
// comparison for now.
|
|
// TODO(BridgeAR): `breakLength` should be limited as soon as soon as we
|
|
// have meta information about the inspected properties (i.e., know where
|
|
// in what line the property starts and ends).
|
|
breakLength: Infinity,
|
|
// Assert does not detect proxies currently.
|
|
showProxy: false,
|
|
sorted: true,
|
|
// Inspect getters as we also check them when comparing entries.
|
|
getters: true
|
|
});
|
|
}
|
|
|
|
function createErrDiff(actual, expected, operator) {
|
|
var other = '';
|
|
var res = '';
|
|
var lastPos = 0;
|
|
var end = '';
|
|
var skipped = false;
|
|
var actualInspected = inspectValue(actual);
|
|
var actualLines = actualInspected.split('\n');
|
|
var expectedLines = inspectValue(expected).split('\n');
|
|
var i = 0;
|
|
var indicator = ''; // In case both values are objects explicitly mark them as not reference equal
|
|
// for the `strictEqual` operator.
|
|
|
|
if (operator === 'strictEqual' && _typeof(actual) === 'object' && _typeof(expected) === 'object' && actual !== null && expected !== null) {
|
|
operator = 'strictEqualObject';
|
|
} // If "actual" and "expected" fit on a single line and they are not strictly
|
|
// equal, check further special handling.
|
|
|
|
|
|
if (actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) {
|
|
var inputLength = actualLines[0].length + expectedLines[0].length; // If the character length of "actual" and "expected" together is less than
|
|
// kMaxShortLength and if neither is an object and at least one of them is
|
|
// not `zero`, use the strict equal comparison to visualize the output.
|
|
|
|
if (inputLength <= kMaxShortLength) {
|
|
if ((_typeof(actual) !== 'object' || actual === null) && (_typeof(expected) !== 'object' || expected === null) && (actual !== 0 || expected !== 0)) {
|
|
// -0 === +0
|
|
return "".concat(kReadableOperator[operator], "\n\n") + "".concat(actualLines[0], " !== ").concat(expectedLines[0], "\n");
|
|
}
|
|
} else if (operator !== 'strictEqualObject') {
|
|
// If the stderr is a tty and the input length is lower than the current
|
|
// columns per line, add a mismatch indicator below the output. If it is
|
|
// not a tty, use a default value of 80 characters.
|
|
var maxLength = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;
|
|
|
|
if (inputLength < maxLength) {
|
|
while (actualLines[0][i] === expectedLines[0][i]) {
|
|
i++;
|
|
} // Ignore the first characters.
|
|
|
|
|
|
if (i > 2) {
|
|
// Add position indicator for the first mismatch in case it is a
|
|
// single line and the input length is less than the column length.
|
|
indicator = "\n ".concat(repeat(' ', i), "^");
|
|
i = 0;
|
|
}
|
|
}
|
|
}
|
|
} // Remove all ending lines that match (this optimizes the output for
|
|
// readability by reducing the number of total changed lines).
|
|
|
|
|
|
var a = actualLines[actualLines.length - 1];
|
|
var b = expectedLines[expectedLines.length - 1];
|
|
|
|
while (a === b) {
|
|
if (i++ < 2) {
|
|
end = "\n ".concat(a).concat(end);
|
|
} else {
|
|
other = a;
|
|
}
|
|
|
|
actualLines.pop();
|
|
expectedLines.pop();
|
|
if (actualLines.length === 0 || expectedLines.length === 0) break;
|
|
a = actualLines[actualLines.length - 1];
|
|
b = expectedLines[expectedLines.length - 1];
|
|
}
|
|
|
|
var maxLines = Math.max(actualLines.length, expectedLines.length); // Strict equal with identical objects that are not identical by reference.
|
|
// E.g., assert.deepStrictEqual({ a: Symbol() }, { a: Symbol() })
|
|
|
|
if (maxLines === 0) {
|
|
// We have to get the result again. The lines were all removed before.
|
|
var _actualLines = actualInspected.split('\n'); // Only remove lines in case it makes sense to collapse those.
|
|
// TODO: Accept env to always show the full error.
|
|
|
|
|
|
if (_actualLines.length > 30) {
|
|
_actualLines[26] = "".concat(blue, "...").concat(white);
|
|
|
|
while (_actualLines.length > 27) {
|
|
_actualLines.pop();
|
|
}
|
|
}
|
|
|
|
return "".concat(kReadableOperator.notIdentical, "\n\n").concat(_actualLines.join('\n'), "\n");
|
|
}
|
|
|
|
if (i > 3) {
|
|
end = "\n".concat(blue, "...").concat(white).concat(end);
|
|
skipped = true;
|
|
}
|
|
|
|
if (other !== '') {
|
|
end = "\n ".concat(other).concat(end);
|
|
other = '';
|
|
}
|
|
|
|
var printedLines = 0;
|
|
var msg = kReadableOperator[operator] + "\n".concat(green, "+ actual").concat(white, " ").concat(red, "- expected").concat(white);
|
|
var skippedMsg = " ".concat(blue, "...").concat(white, " Lines skipped");
|
|
|
|
for (i = 0; i < maxLines; i++) {
|
|
// Only extra expected lines exist
|
|
var cur = i - lastPos;
|
|
|
|
if (actualLines.length < i + 1) {
|
|
// If the last diverging line is more than one line above and the
|
|
// current line is at least line three, add some of the former lines and
|
|
// also add dots to indicate skipped entries.
|
|
if (cur > 1 && i > 2) {
|
|
if (cur > 4) {
|
|
res += "\n".concat(blue, "...").concat(white);
|
|
skipped = true;
|
|
} else if (cur > 3) {
|
|
res += "\n ".concat(expectedLines[i - 2]);
|
|
printedLines++;
|
|
}
|
|
|
|
res += "\n ".concat(expectedLines[i - 1]);
|
|
printedLines++;
|
|
} // Mark the current line as the last diverging one.
|
|
|
|
|
|
lastPos = i; // Add the expected line to the cache.
|
|
|
|
other += "\n".concat(red, "-").concat(white, " ").concat(expectedLines[i]);
|
|
printedLines++; // Only extra actual lines exist
|
|
} else if (expectedLines.length < i + 1) {
|
|
// If the last diverging line is more than one line above and the
|
|
// current line is at least line three, add some of the former lines and
|
|
// also add dots to indicate skipped entries.
|
|
if (cur > 1 && i > 2) {
|
|
if (cur > 4) {
|
|
res += "\n".concat(blue, "...").concat(white);
|
|
skipped = true;
|
|
} else if (cur > 3) {
|
|
res += "\n ".concat(actualLines[i - 2]);
|
|
printedLines++;
|
|
}
|
|
|
|
res += "\n ".concat(actualLines[i - 1]);
|
|
printedLines++;
|
|
} // Mark the current line as the last diverging one.
|
|
|
|
|
|
lastPos = i; // Add the actual line to the result.
|
|
|
|
res += "\n".concat(green, "+").concat(white, " ").concat(actualLines[i]);
|
|
printedLines++; // Lines diverge
|
|
} else {
|
|
var expectedLine = expectedLines[i];
|
|
var actualLine = actualLines[i]; // If the lines diverge, specifically check for lines that only diverge by
|
|
// a trailing comma. In that case it is actually identical and we should
|
|
// mark it as such.
|
|
|
|
var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ',') || actualLine.slice(0, -1) !== expectedLine); // If the expected line has a trailing comma but is otherwise identical,
|
|
// add a comma at the end of the actual line. Otherwise the output could
|
|
// look weird as in:
|
|
//
|
|
// [
|
|
// 1 // No comma at the end!
|
|
// + 2
|
|
// ]
|
|
//
|
|
|
|
if (divergingLines && endsWith(expectedLine, ',') && expectedLine.slice(0, -1) === actualLine) {
|
|
divergingLines = false;
|
|
actualLine += ',';
|
|
}
|
|
|
|
if (divergingLines) {
|
|
// If the last diverging line is more than one line above and the
|
|
// current line is at least line three, add some of the former lines and
|
|
// also add dots to indicate skipped entries.
|
|
if (cur > 1 && i > 2) {
|
|
if (cur > 4) {
|
|
res += "\n".concat(blue, "...").concat(white);
|
|
skipped = true;
|
|
} else if (cur > 3) {
|
|
res += "\n ".concat(actualLines[i - 2]);
|
|
printedLines++;
|
|
}
|
|
|
|
res += "\n ".concat(actualLines[i - 1]);
|
|
printedLines++;
|
|
} // Mark the current line as the last diverging one.
|
|
|
|
|
|
lastPos = i; // Add the actual line to the result and cache the expected diverging
|
|
// line so consecutive diverging lines show up as +++--- and not +-+-+-.
|
|
|
|
res += "\n".concat(green, "+").concat(white, " ").concat(actualLine);
|
|
other += "\n".concat(red, "-").concat(white, " ").concat(expectedLine);
|
|
printedLines += 2; // Lines are identical
|
|
} else {
|
|
// Add all cached information to the result before adding other things
|
|
// and reset the cache.
|
|
res += other;
|
|
other = ''; // If the last diverging line is exactly one line above or if it is the
|
|
// very first line, add the line to the result.
|
|
|
|
if (cur === 1 || i === 0) {
|
|
res += "\n ".concat(actualLine);
|
|
printedLines++;
|
|
}
|
|
}
|
|
} // Inspected object to big (Show ~20 rows max)
|
|
|
|
|
|
if (printedLines > 20 && i < maxLines - 2) {
|
|
return "".concat(msg).concat(skippedMsg, "\n").concat(res, "\n").concat(blue, "...").concat(white).concat(other, "\n") + "".concat(blue, "...").concat(white);
|
|
}
|
|
}
|
|
|
|
return "".concat(msg).concat(skipped ? skippedMsg : '', "\n").concat(res).concat(other).concat(end).concat(indicator);
|
|
}
|
|
|
|
var AssertionError =
|
|
/*#__PURE__*/
|
|
function (_Error) {
|
|
_inherits(AssertionError, _Error);
|
|
|
|
function AssertionError(options) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, AssertionError);
|
|
|
|
if (_typeof(options) !== 'object' || options === null) {
|
|
throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
|
|
}
|
|
|
|
var message = options.message,
|
|
operator = options.operator,
|
|
stackStartFn = options.stackStartFn;
|
|
var actual = options.actual,
|
|
expected = options.expected;
|
|
var limit = Error.stackTraceLimit;
|
|
Error.stackTraceLimit = 0;
|
|
|
|
if (message != null) {
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, String(message)));
|
|
} else {
|
|
if (process.stderr && process.stderr.isTTY) {
|
|
// Reset on each call to make sure we handle dynamically set environment
|
|
// variables correct.
|
|
if (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1) {
|
|
blue = "\x1B[34m";
|
|
green = "\x1B[32m";
|
|
white = "\x1B[39m";
|
|
red = "\x1B[31m";
|
|
} else {
|
|
blue = '';
|
|
green = '';
|
|
white = '';
|
|
red = '';
|
|
}
|
|
} // Prevent the error stack from being visible by duplicating the error
|
|
// in a very close way to the original in case both sides are actually
|
|
// instances of Error.
|
|
|
|
|
|
if (_typeof(actual) === 'object' && actual !== null && _typeof(expected) === 'object' && expected !== null && 'stack' in actual && actual instanceof Error && 'stack' in expected && expected instanceof Error) {
|
|
actual = copyError(actual);
|
|
expected = copyError(expected);
|
|
}
|
|
|
|
if (operator === 'deepStrictEqual' || operator === 'strictEqual') {
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, createErrDiff(actual, expected, operator)));
|
|
} else if (operator === 'notDeepStrictEqual' || operator === 'notStrictEqual') {
|
|
// In case the objects are equal but the operator requires unequal, show
|
|
// the first object and say A equals B
|
|
var base = kReadableOperator[operator];
|
|
var res = inspectValue(actual).split('\n'); // In case "actual" is an object, it should not be reference equal.
|
|
|
|
if (operator === 'notStrictEqual' && _typeof(actual) === 'object' && actual !== null) {
|
|
base = kReadableOperator.notStrictEqualObject;
|
|
} // Only remove lines in case it makes sense to collapse those.
|
|
// TODO: Accept env to always show the full error.
|
|
|
|
|
|
if (res.length > 30) {
|
|
res[26] = "".concat(blue, "...").concat(white);
|
|
|
|
while (res.length > 27) {
|
|
res.pop();
|
|
}
|
|
} // Only print a single input.
|
|
|
|
|
|
if (res.length === 1) {
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, "".concat(base, " ").concat(res[0])));
|
|
} else {
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, "".concat(base, "\n\n").concat(res.join('\n'), "\n")));
|
|
}
|
|
} else {
|
|
var _res = inspectValue(actual);
|
|
|
|
var other = '';
|
|
var knownOperators = kReadableOperator[operator];
|
|
|
|
if (operator === 'notDeepEqual' || operator === 'notEqual') {
|
|
_res = "".concat(kReadableOperator[operator], "\n\n").concat(_res);
|
|
|
|
if (_res.length > 1024) {
|
|
_res = "".concat(_res.slice(0, 1021), "...");
|
|
}
|
|
} else {
|
|
other = "".concat(inspectValue(expected));
|
|
|
|
if (_res.length > 512) {
|
|
_res = "".concat(_res.slice(0, 509), "...");
|
|
}
|
|
|
|
if (other.length > 512) {
|
|
other = "".concat(other.slice(0, 509), "...");
|
|
}
|
|
|
|
if (operator === 'deepEqual' || operator === 'equal') {
|
|
_res = "".concat(knownOperators, "\n\n").concat(_res, "\n\nshould equal\n\n");
|
|
} else {
|
|
other = " ".concat(operator, " ").concat(other);
|
|
}
|
|
}
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, "".concat(_res).concat(other)));
|
|
}
|
|
}
|
|
|
|
Error.stackTraceLimit = limit;
|
|
_this.generatedMessage = !message;
|
|
Object.defineProperty(_assertThisInitialized(_this), 'name', {
|
|
value: 'AssertionError [ERR_ASSERTION]',
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
_this.code = 'ERR_ASSERTION';
|
|
_this.actual = actual;
|
|
_this.expected = expected;
|
|
_this.operator = operator;
|
|
|
|
if (Error.captureStackTrace) {
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);
|
|
} // Create error message including the error code in the name.
|
|
|
|
|
|
_this.stack; // Reset the name.
|
|
|
|
_this.name = 'AssertionError';
|
|
return _possibleConstructorReturn(_this);
|
|
}
|
|
|
|
_createClass(AssertionError, [{
|
|
key: "toString",
|
|
value: function toString() {
|
|
return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message);
|
|
}
|
|
}, {
|
|
key: inspect.custom,
|
|
value: function value(recurseTimes, ctx) {
|
|
// This limits the `actual` and `expected` property default inspection to
|
|
// the minimum depth. Otherwise those values would be too verbose compared
|
|
// to the actual error message which contains a combined view of these two
|
|
// input values.
|
|
return inspect(this, _objectSpread({}, ctx, {
|
|
customInspect: false,
|
|
depth: 0
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return AssertionError;
|
|
}(_wrapNativeSuper(Error));
|
|
|
|
module.exports = AssertionError;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1342:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
// Currently in sync with Node.js lib/internal/errors.js
|
|
// https://github.com/nodejs/node/commit/3b044962c48fe313905877a96b5d0894a5404f6f
|
|
|
|
/* eslint node-core/documented-errors: "error" */
|
|
|
|
/* eslint node-core/alphabetize-errors: "error" */
|
|
|
|
/* eslint node-core/prefer-util-format-errors: "error" */
|
|
// The whole point behind this internal module is to allow Node.js to no
|
|
// longer be forced to treat every error message change as a semver-major
|
|
// change. The NodeError classes here all expose a `code` property whose
|
|
// value statically and permanently identifies the error. While the error
|
|
// message may change, the code should not.
|
|
|
|
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
var codes = {}; // Lazy loaded
|
|
|
|
var assert;
|
|
var util;
|
|
|
|
function createErrorType(code, message, Base) {
|
|
if (!Base) {
|
|
Base = Error;
|
|
}
|
|
|
|
function getMessage(arg1, arg2, arg3) {
|
|
if (typeof message === 'string') {
|
|
return message;
|
|
} else {
|
|
return message(arg1, arg2, arg3);
|
|
}
|
|
}
|
|
|
|
var NodeError =
|
|
/*#__PURE__*/
|
|
function (_Base) {
|
|
_inherits(NodeError, _Base);
|
|
|
|
function NodeError(arg1, arg2, arg3) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, NodeError);
|
|
|
|
_this = _possibleConstructorReturn(this, _getPrototypeOf(NodeError).call(this, getMessage(arg1, arg2, arg3)));
|
|
_this.code = code;
|
|
return _this;
|
|
}
|
|
|
|
return NodeError;
|
|
}(Base);
|
|
|
|
codes[code] = NodeError;
|
|
} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
|
|
|
|
|
|
function oneOf(expected, thing) {
|
|
if (Array.isArray(expected)) {
|
|
var len = expected.length;
|
|
expected = expected.map(function (i) {
|
|
return String(i);
|
|
});
|
|
|
|
if (len > 2) {
|
|
return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
|
|
} else if (len === 2) {
|
|
return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
|
|
} else {
|
|
return "of ".concat(thing, " ").concat(expected[0]);
|
|
}
|
|
} else {
|
|
return "of ".concat(thing, " ").concat(String(expected));
|
|
}
|
|
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
|
|
|
|
|
|
function startsWith(str, search, pos) {
|
|
return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
|
|
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
|
|
|
|
|
|
function endsWith(str, search, this_len) {
|
|
if (this_len === undefined || this_len > str.length) {
|
|
this_len = str.length;
|
|
}
|
|
|
|
return str.substring(this_len - search.length, this_len) === search;
|
|
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
|
|
|
|
|
|
function includes(str, search, start) {
|
|
if (typeof start !== 'number') {
|
|
start = 0;
|
|
}
|
|
|
|
if (start + search.length > str.length) {
|
|
return false;
|
|
} else {
|
|
return str.indexOf(search, start) !== -1;
|
|
}
|
|
}
|
|
|
|
createErrorType('ERR_AMBIGUOUS_ARGUMENT', 'The "%s" argument is ambiguous. %s', TypeError);
|
|
createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
|
|
if (assert === undefined) assert = __webpack_require__(6093);
|
|
assert(typeof name === 'string', "'name' must be a string"); // determiner: 'must be' or 'must not be'
|
|
|
|
var determiner;
|
|
|
|
if (typeof expected === 'string' && startsWith(expected, 'not ')) {
|
|
determiner = 'must not be';
|
|
expected = expected.replace(/^not /, '');
|
|
} else {
|
|
determiner = 'must be';
|
|
}
|
|
|
|
var msg;
|
|
|
|
if (endsWith(name, ' argument')) {
|
|
// For cases like 'first argument'
|
|
msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
|
|
} else {
|
|
var type = includes(name, '.') ? 'property' : 'argument';
|
|
msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
|
|
} // TODO(BridgeAR): Improve the output by showing `null` and similar.
|
|
|
|
|
|
msg += ". Received type ".concat(_typeof(actual));
|
|
return msg;
|
|
}, TypeError);
|
|
createErrorType('ERR_INVALID_ARG_VALUE', function (name, value) {
|
|
var reason = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'is invalid';
|
|
if (util === undefined) util = __webpack_require__(6827);
|
|
var inspected = util.inspect(value);
|
|
|
|
if (inspected.length > 128) {
|
|
inspected = "".concat(inspected.slice(0, 128), "...");
|
|
}
|
|
|
|
return "The argument '".concat(name, "' ").concat(reason, ". Received ").concat(inspected);
|
|
}, TypeError, RangeError);
|
|
createErrorType('ERR_INVALID_RETURN_VALUE', function (input, name, value) {
|
|
var type;
|
|
|
|
if (value && value.constructor && value.constructor.name) {
|
|
type = "instance of ".concat(value.constructor.name);
|
|
} else {
|
|
type = "type ".concat(_typeof(value));
|
|
}
|
|
|
|
return "Expected ".concat(input, " to be returned from the \"").concat(name, "\"") + " function but got ".concat(type, ".");
|
|
}, TypeError);
|
|
createErrorType('ERR_MISSING_ARGS', function () {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
if (assert === undefined) assert = __webpack_require__(6093);
|
|
assert(args.length > 0, 'At least one arg needs to be specified');
|
|
var msg = 'The ';
|
|
var len = args.length;
|
|
args = args.map(function (a) {
|
|
return "\"".concat(a, "\"");
|
|
});
|
|
|
|
switch (len) {
|
|
case 1:
|
|
msg += "".concat(args[0], " argument");
|
|
break;
|
|
|
|
case 2:
|
|
msg += "".concat(args[0], " and ").concat(args[1], " arguments");
|
|
break;
|
|
|
|
default:
|
|
msg += args.slice(0, len - 1).join(', ');
|
|
msg += ", and ".concat(args[len - 1], " arguments");
|
|
break;
|
|
}
|
|
|
|
return "".concat(msg, " must be specified");
|
|
}, TypeError);
|
|
module.exports.codes = codes;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5656:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
// Currently in sync with Node.js lib/internal/util/comparisons.js
|
|
// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
|
|
|
|
|
|
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
|
|
|
|
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
|
|
|
|
function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
|
|
|
|
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
|
|
|
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
var regexFlagsSupported = /a/g.flags !== undefined;
|
|
|
|
var arrayFromSet = function arrayFromSet(set) {
|
|
var array = [];
|
|
set.forEach(function (value) {
|
|
return array.push(value);
|
|
});
|
|
return array;
|
|
};
|
|
|
|
var arrayFromMap = function arrayFromMap(map) {
|
|
var array = [];
|
|
map.forEach(function (value, key) {
|
|
return array.push([key, value]);
|
|
});
|
|
return array;
|
|
};
|
|
|
|
var objectIs = Object.is ? Object.is : __webpack_require__(5968);
|
|
var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function () {
|
|
return [];
|
|
};
|
|
var numberIsNaN = Number.isNaN ? Number.isNaN : __webpack_require__(7838);
|
|
|
|
function uncurryThis(f) {
|
|
return f.call.bind(f);
|
|
}
|
|
|
|
var hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
|
|
var propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);
|
|
var objectToString = uncurryThis(Object.prototype.toString);
|
|
|
|
var _require$types = (__webpack_require__(6827).types),
|
|
isAnyArrayBuffer = _require$types.isAnyArrayBuffer,
|
|
isArrayBufferView = _require$types.isArrayBufferView,
|
|
isDate = _require$types.isDate,
|
|
isMap = _require$types.isMap,
|
|
isRegExp = _require$types.isRegExp,
|
|
isSet = _require$types.isSet,
|
|
isNativeError = _require$types.isNativeError,
|
|
isBoxedPrimitive = _require$types.isBoxedPrimitive,
|
|
isNumberObject = _require$types.isNumberObject,
|
|
isStringObject = _require$types.isStringObject,
|
|
isBooleanObject = _require$types.isBooleanObject,
|
|
isBigIntObject = _require$types.isBigIntObject,
|
|
isSymbolObject = _require$types.isSymbolObject,
|
|
isFloat32Array = _require$types.isFloat32Array,
|
|
isFloat64Array = _require$types.isFloat64Array;
|
|
|
|
function isNonIndex(key) {
|
|
if (key.length === 0 || key.length > 10) return true;
|
|
|
|
for (var i = 0; i < key.length; i++) {
|
|
var code = key.charCodeAt(i);
|
|
if (code < 48 || code > 57) return true;
|
|
} // The maximum size for an array is 2 ** 32 -1.
|
|
|
|
|
|
return key.length === 10 && key >= Math.pow(2, 32);
|
|
}
|
|
|
|
function getOwnNonIndexProperties(value) {
|
|
return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value)));
|
|
} // Taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js
|
|
// original notice:
|
|
|
|
/*!
|
|
* The buffer module from node.js, for the browser.
|
|
*
|
|
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
|
* @license MIT
|
|
*/
|
|
|
|
|
|
function compare(a, b) {
|
|
if (a === b) {
|
|
return 0;
|
|
}
|
|
|
|
var x = a.length;
|
|
var y = b.length;
|
|
|
|
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
|
|
if (a[i] !== b[i]) {
|
|
x = a[i];
|
|
y = b[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (x < y) {
|
|
return -1;
|
|
}
|
|
|
|
if (y < x) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
var ONLY_ENUMERABLE = undefined;
|
|
var kStrict = true;
|
|
var kLoose = false;
|
|
var kNoIterator = 0;
|
|
var kIsArray = 1;
|
|
var kIsSet = 2;
|
|
var kIsMap = 3; // Check if they have the same source and flags
|
|
|
|
function areSimilarRegExps(a, b) {
|
|
return regexFlagsSupported ? a.source === b.source && a.flags === b.flags : RegExp.prototype.toString.call(a) === RegExp.prototype.toString.call(b);
|
|
}
|
|
|
|
function areSimilarFloatArrays(a, b) {
|
|
if (a.byteLength !== b.byteLength) {
|
|
return false;
|
|
}
|
|
|
|
for (var offset = 0; offset < a.byteLength; offset++) {
|
|
if (a[offset] !== b[offset]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function areSimilarTypedArrays(a, b) {
|
|
if (a.byteLength !== b.byteLength) {
|
|
return false;
|
|
}
|
|
|
|
return compare(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0;
|
|
}
|
|
|
|
function areEqualArrayBuffers(buf1, buf2) {
|
|
return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;
|
|
}
|
|
|
|
function isEqualBoxedPrimitive(val1, val2) {
|
|
if (isNumberObject(val1)) {
|
|
return isNumberObject(val2) && objectIs(Number.prototype.valueOf.call(val1), Number.prototype.valueOf.call(val2));
|
|
}
|
|
|
|
if (isStringObject(val1)) {
|
|
return isStringObject(val2) && String.prototype.valueOf.call(val1) === String.prototype.valueOf.call(val2);
|
|
}
|
|
|
|
if (isBooleanObject(val1)) {
|
|
return isBooleanObject(val2) && Boolean.prototype.valueOf.call(val1) === Boolean.prototype.valueOf.call(val2);
|
|
}
|
|
|
|
if (isBigIntObject(val1)) {
|
|
return isBigIntObject(val2) && BigInt.prototype.valueOf.call(val1) === BigInt.prototype.valueOf.call(val2);
|
|
}
|
|
|
|
return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2);
|
|
} // Notes: Type tags are historical [[Class]] properties that can be set by
|
|
// FunctionTemplate::SetClassName() in C++ or Symbol.toStringTag in JS
|
|
// and retrieved using Object.prototype.toString.call(obj) in JS
|
|
// See https://tc39.github.io/ecma262/#sec-object.prototype.tostring
|
|
// for a list of tags pre-defined in the spec.
|
|
// There are some unspecified tags in the wild too (e.g. typed array tags).
|
|
// Since tags can be altered, they only serve fast failures
|
|
//
|
|
// Typed arrays and buffers are checked by comparing the content in their
|
|
// underlying ArrayBuffer. This optimization requires that it's
|
|
// reasonable to interpret their underlying memory in the same way,
|
|
// which is checked by comparing their type tags.
|
|
// (e.g. a Uint8Array and a Uint16Array with the same memory content
|
|
// could still be different because they will be interpreted differently).
|
|
//
|
|
// For strict comparison, objects should have
|
|
// a) The same built-in type tags
|
|
// b) The same prototypes.
|
|
|
|
|
|
function innerDeepEqual(val1, val2, strict, memos) {
|
|
// All identical values are equivalent, as determined by ===.
|
|
if (val1 === val2) {
|
|
if (val1 !== 0) return true;
|
|
return strict ? objectIs(val1, val2) : true;
|
|
} // Check more closely if val1 and val2 are equal.
|
|
|
|
|
|
if (strict) {
|
|
if (_typeof(val1) !== 'object') {
|
|
return typeof val1 === 'number' && numberIsNaN(val1) && numberIsNaN(val2);
|
|
}
|
|
|
|
if (_typeof(val2) !== 'object' || val1 === null || val2 === null) {
|
|
return false;
|
|
}
|
|
|
|
if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (val1 === null || _typeof(val1) !== 'object') {
|
|
if (val2 === null || _typeof(val2) !== 'object') {
|
|
// eslint-disable-next-line eqeqeq
|
|
return val1 == val2;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (val2 === null || _typeof(val2) !== 'object') {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
var val1Tag = objectToString(val1);
|
|
var val2Tag = objectToString(val2);
|
|
|
|
if (val1Tag !== val2Tag) {
|
|
return false;
|
|
}
|
|
|
|
if (Array.isArray(val1)) {
|
|
// Check for sparse arrays and general fast path
|
|
if (val1.length !== val2.length) {
|
|
return false;
|
|
}
|
|
|
|
var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
|
|
var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
|
|
|
|
if (keys1.length !== keys2.length) {
|
|
return false;
|
|
}
|
|
|
|
return keyCheck(val1, val2, strict, memos, kIsArray, keys1);
|
|
} // [browserify] This triggers on certain types in IE (Map/Set) so we don't
|
|
// wan't to early return out of the rest of the checks. However we can check
|
|
// if the second value is one of these values and the first isn't.
|
|
|
|
|
|
if (val1Tag === '[object Object]') {
|
|
// return keyCheck(val1, val2, strict, memos, kNoIterator);
|
|
if (!isMap(val1) && isMap(val2) || !isSet(val1) && isSet(val2)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (isDate(val1)) {
|
|
if (!isDate(val2) || Date.prototype.getTime.call(val1) !== Date.prototype.getTime.call(val2)) {
|
|
return false;
|
|
}
|
|
} else if (isRegExp(val1)) {
|
|
if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) {
|
|
return false;
|
|
}
|
|
} else if (isNativeError(val1) || val1 instanceof Error) {
|
|
// Do not compare the stack as it might differ even though the error itself
|
|
// is otherwise identical.
|
|
if (val1.message !== val2.message || val1.name !== val2.name) {
|
|
return false;
|
|
}
|
|
} else if (isArrayBufferView(val1)) {
|
|
if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {
|
|
if (!areSimilarFloatArrays(val1, val2)) {
|
|
return false;
|
|
}
|
|
} else if (!areSimilarTypedArrays(val1, val2)) {
|
|
return false;
|
|
} // Buffer.compare returns true, so val1.length === val2.length. If they both
|
|
// only contain numeric keys, we don't need to exam further than checking
|
|
// the symbols.
|
|
|
|
|
|
var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
|
|
|
|
var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
|
|
|
|
if (_keys.length !== _keys2.length) {
|
|
return false;
|
|
}
|
|
|
|
return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);
|
|
} else if (isSet(val1)) {
|
|
if (!isSet(val2) || val1.size !== val2.size) {
|
|
return false;
|
|
}
|
|
|
|
return keyCheck(val1, val2, strict, memos, kIsSet);
|
|
} else if (isMap(val1)) {
|
|
if (!isMap(val2) || val1.size !== val2.size) {
|
|
return false;
|
|
}
|
|
|
|
return keyCheck(val1, val2, strict, memos, kIsMap);
|
|
} else if (isAnyArrayBuffer(val1)) {
|
|
if (!areEqualArrayBuffers(val1, val2)) {
|
|
return false;
|
|
}
|
|
} else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) {
|
|
return false;
|
|
}
|
|
|
|
return keyCheck(val1, val2, strict, memos, kNoIterator);
|
|
}
|
|
|
|
function getEnumerables(val, keys) {
|
|
return keys.filter(function (k) {
|
|
return propertyIsEnumerable(val, k);
|
|
});
|
|
}
|
|
|
|
function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
|
|
// For all remaining Object pairs, including Array, objects and Maps,
|
|
// equivalence is determined by having:
|
|
// a) The same number of owned enumerable properties
|
|
// b) The same set of keys/indexes (although not necessarily the same order)
|
|
// c) Equivalent values for every corresponding key/index
|
|
// d) For Sets and Maps, equal contents
|
|
// Note: this accounts for both named and indexed properties on Arrays.
|
|
if (arguments.length === 5) {
|
|
aKeys = Object.keys(val1);
|
|
var bKeys = Object.keys(val2); // The pair must have the same number of owned properties.
|
|
|
|
if (aKeys.length !== bKeys.length) {
|
|
return false;
|
|
}
|
|
} // Cheap key test
|
|
|
|
|
|
var i = 0;
|
|
|
|
for (; i < aKeys.length; i++) {
|
|
if (!hasOwnProperty(val2, aKeys[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (strict && arguments.length === 5) {
|
|
var symbolKeysA = objectGetOwnPropertySymbols(val1);
|
|
|
|
if (symbolKeysA.length !== 0) {
|
|
var count = 0;
|
|
|
|
for (i = 0; i < symbolKeysA.length; i++) {
|
|
var key = symbolKeysA[i];
|
|
|
|
if (propertyIsEnumerable(val1, key)) {
|
|
if (!propertyIsEnumerable(val2, key)) {
|
|
return false;
|
|
}
|
|
|
|
aKeys.push(key);
|
|
count++;
|
|
} else if (propertyIsEnumerable(val2, key)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
var symbolKeysB = objectGetOwnPropertySymbols(val2);
|
|
|
|
if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count) {
|
|
return false;
|
|
}
|
|
} else {
|
|
var _symbolKeysB = objectGetOwnPropertySymbols(val2);
|
|
|
|
if (_symbolKeysB.length !== 0 && getEnumerables(val2, _symbolKeysB).length !== 0) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aKeys.length === 0 && (iterationType === kNoIterator || iterationType === kIsArray && val1.length === 0 || val1.size === 0)) {
|
|
return true;
|
|
} // Use memos to handle cycles.
|
|
|
|
|
|
if (memos === undefined) {
|
|
memos = {
|
|
val1: new Map(),
|
|
val2: new Map(),
|
|
position: 0
|
|
};
|
|
} else {
|
|
// We prevent up to two map.has(x) calls by directly retrieving the value
|
|
// and checking for undefined. The map can only contain numbers, so it is
|
|
// safe to check for undefined only.
|
|
var val2MemoA = memos.val1.get(val1);
|
|
|
|
if (val2MemoA !== undefined) {
|
|
var val2MemoB = memos.val2.get(val2);
|
|
|
|
if (val2MemoB !== undefined) {
|
|
return val2MemoA === val2MemoB;
|
|
}
|
|
}
|
|
|
|
memos.position++;
|
|
}
|
|
|
|
memos.val1.set(val1, memos.position);
|
|
memos.val2.set(val2, memos.position);
|
|
var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType);
|
|
memos.val1.delete(val1);
|
|
memos.val2.delete(val2);
|
|
return areEq;
|
|
}
|
|
|
|
function setHasEqualElement(set, val1, strict, memo) {
|
|
// Go looking.
|
|
var setValues = arrayFromSet(set);
|
|
|
|
for (var i = 0; i < setValues.length; i++) {
|
|
var val2 = setValues[i];
|
|
|
|
if (innerDeepEqual(val1, val2, strict, memo)) {
|
|
// Remove the matching element to make sure we do not check that again.
|
|
set.delete(val2);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
} // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Loose_equality_using
|
|
// Sadly it is not possible to detect corresponding values properly in case the
|
|
// type is a string, number, bigint or boolean. The reason is that those values
|
|
// can match lots of different string values (e.g., 1n == '+00001').
|
|
|
|
|
|
function findLooseMatchingPrimitives(prim) {
|
|
switch (_typeof(prim)) {
|
|
case 'undefined':
|
|
return null;
|
|
|
|
case 'object':
|
|
// Only pass in null as object!
|
|
return undefined;
|
|
|
|
case 'symbol':
|
|
return false;
|
|
|
|
case 'string':
|
|
prim = +prim;
|
|
// Loose equal entries exist only if the string is possible to convert to
|
|
// a regular number and not NaN.
|
|
// Fall through
|
|
|
|
case 'number':
|
|
if (numberIsNaN(prim)) {
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function setMightHaveLoosePrim(a, b, prim) {
|
|
var altValue = findLooseMatchingPrimitives(prim);
|
|
if (altValue != null) return altValue;
|
|
return b.has(altValue) && !a.has(altValue);
|
|
}
|
|
|
|
function mapMightHaveLoosePrim(a, b, prim, item, memo) {
|
|
var altValue = findLooseMatchingPrimitives(prim);
|
|
|
|
if (altValue != null) {
|
|
return altValue;
|
|
}
|
|
|
|
var curB = b.get(altValue);
|
|
|
|
if (curB === undefined && !b.has(altValue) || !innerDeepEqual(item, curB, false, memo)) {
|
|
return false;
|
|
}
|
|
|
|
return !a.has(altValue) && innerDeepEqual(item, curB, false, memo);
|
|
}
|
|
|
|
function setEquiv(a, b, strict, memo) {
|
|
// This is a lazily initiated Set of entries which have to be compared
|
|
// pairwise.
|
|
var set = null;
|
|
var aValues = arrayFromSet(a);
|
|
|
|
for (var i = 0; i < aValues.length; i++) {
|
|
var val = aValues[i]; // Note: Checking for the objects first improves the performance for object
|
|
// heavy sets but it is a minor slow down for primitives. As they are fast
|
|
// to check this improves the worst case scenario instead.
|
|
|
|
if (_typeof(val) === 'object' && val !== null) {
|
|
if (set === null) {
|
|
set = new Set();
|
|
} // If the specified value doesn't exist in the second set its an not null
|
|
// object (or non strict only: a not matching primitive) we'll need to go
|
|
// hunting for something thats deep-(strict-)equal to it. To make this
|
|
// O(n log n) complexity we have to copy these values in a new set first.
|
|
|
|
|
|
set.add(val);
|
|
} else if (!b.has(val)) {
|
|
if (strict) return false; // Fast path to detect missing string, symbol, undefined and null values.
|
|
|
|
if (!setMightHaveLoosePrim(a, b, val)) {
|
|
return false;
|
|
}
|
|
|
|
if (set === null) {
|
|
set = new Set();
|
|
}
|
|
|
|
set.add(val);
|
|
}
|
|
}
|
|
|
|
if (set !== null) {
|
|
var bValues = arrayFromSet(b);
|
|
|
|
for (var _i = 0; _i < bValues.length; _i++) {
|
|
var _val = bValues[_i]; // We have to check if a primitive value is already
|
|
// matching and only if it's not, go hunting for it.
|
|
|
|
if (_typeof(_val) === 'object' && _val !== null) {
|
|
if (!setHasEqualElement(set, _val, strict, memo)) return false;
|
|
} else if (!strict && !a.has(_val) && !setHasEqualElement(set, _val, strict, memo)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return set.size === 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function mapHasEqualEntry(set, map, key1, item1, strict, memo) {
|
|
// To be able to handle cases like:
|
|
// Map([[{}, 'a'], [{}, 'b']]) vs Map([[{}, 'b'], [{}, 'a']])
|
|
// ... we need to consider *all* matching keys, not just the first we find.
|
|
var setValues = arrayFromSet(set);
|
|
|
|
for (var i = 0; i < setValues.length; i++) {
|
|
var key2 = setValues[i];
|
|
|
|
if (innerDeepEqual(key1, key2, strict, memo) && innerDeepEqual(item1, map.get(key2), strict, memo)) {
|
|
set.delete(key2);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function mapEquiv(a, b, strict, memo) {
|
|
var set = null;
|
|
var aEntries = arrayFromMap(a);
|
|
|
|
for (var i = 0; i < aEntries.length; i++) {
|
|
var _aEntries$i = _slicedToArray(aEntries[i], 2),
|
|
key = _aEntries$i[0],
|
|
item1 = _aEntries$i[1];
|
|
|
|
if (_typeof(key) === 'object' && key !== null) {
|
|
if (set === null) {
|
|
set = new Set();
|
|
}
|
|
|
|
set.add(key);
|
|
} else {
|
|
// By directly retrieving the value we prevent another b.has(key) check in
|
|
// almost all possible cases.
|
|
var item2 = b.get(key);
|
|
|
|
if (item2 === undefined && !b.has(key) || !innerDeepEqual(item1, item2, strict, memo)) {
|
|
if (strict) return false; // Fast path to detect missing string, symbol, undefined and null
|
|
// keys.
|
|
|
|
if (!mapMightHaveLoosePrim(a, b, key, item1, memo)) return false;
|
|
|
|
if (set === null) {
|
|
set = new Set();
|
|
}
|
|
|
|
set.add(key);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (set !== null) {
|
|
var bEntries = arrayFromMap(b);
|
|
|
|
for (var _i2 = 0; _i2 < bEntries.length; _i2++) {
|
|
var _bEntries$_i = _slicedToArray(bEntries[_i2], 2),
|
|
key = _bEntries$_i[0],
|
|
item = _bEntries$_i[1];
|
|
|
|
if (_typeof(key) === 'object' && key !== null) {
|
|
if (!mapHasEqualEntry(set, a, key, item, strict, memo)) return false;
|
|
} else if (!strict && (!a.has(key) || !innerDeepEqual(a.get(key), item, false, memo)) && !mapHasEqualEntry(set, a, key, item, false, memo)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return set.size === 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function objEquiv(a, b, strict, keys, memos, iterationType) {
|
|
// Sets and maps don't have their entries accessible via normal object
|
|
// properties.
|
|
var i = 0;
|
|
|
|
if (iterationType === kIsSet) {
|
|
if (!setEquiv(a, b, strict, memos)) {
|
|
return false;
|
|
}
|
|
} else if (iterationType === kIsMap) {
|
|
if (!mapEquiv(a, b, strict, memos)) {
|
|
return false;
|
|
}
|
|
} else if (iterationType === kIsArray) {
|
|
for (; i < a.length; i++) {
|
|
if (hasOwnProperty(a, i)) {
|
|
if (!hasOwnProperty(b, i) || !innerDeepEqual(a[i], b[i], strict, memos)) {
|
|
return false;
|
|
}
|
|
} else if (hasOwnProperty(b, i)) {
|
|
return false;
|
|
} else {
|
|
// Array is sparse.
|
|
var keysA = Object.keys(a);
|
|
|
|
for (; i < keysA.length; i++) {
|
|
var key = keysA[i];
|
|
|
|
if (!hasOwnProperty(b, key) || !innerDeepEqual(a[key], b[key], strict, memos)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (keysA.length !== Object.keys(b).length) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
} // The pair must have equivalent values for every corresponding key.
|
|
// Possibly expensive deep test:
|
|
|
|
|
|
for (i = 0; i < keys.length; i++) {
|
|
var _key = keys[i];
|
|
|
|
if (!innerDeepEqual(a[_key], b[_key], strict, memos)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function isDeepEqual(val1, val2) {
|
|
return innerDeepEqual(val1, val2, kLoose);
|
|
}
|
|
|
|
function isDeepStrictEqual(val1, val2) {
|
|
return innerDeepEqual(val1, val2, kStrict);
|
|
}
|
|
|
|
module.exports = {
|
|
isDeepEqual: isDeepEqual,
|
|
isDeepStrictEqual: isDeepStrictEqual
|
|
};
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9818:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var GetIntrinsic = __webpack_require__(528);
|
|
|
|
var callBind = __webpack_require__(8498);
|
|
|
|
var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));
|
|
|
|
module.exports = function callBoundIntrinsic(name, allowMissing) {
|
|
var intrinsic = GetIntrinsic(name, !!allowMissing);
|
|
if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
|
|
return callBind(intrinsic);
|
|
}
|
|
return intrinsic;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8498:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var bind = __webpack_require__(9138);
|
|
var GetIntrinsic = __webpack_require__(528);
|
|
var setFunctionLength = __webpack_require__(6108);
|
|
|
|
var $TypeError = __webpack_require__(3468);
|
|
var $apply = GetIntrinsic('%Function.prototype.apply%');
|
|
var $call = GetIntrinsic('%Function.prototype.call%');
|
|
var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);
|
|
|
|
var $defineProperty = __webpack_require__(4940);
|
|
var $max = GetIntrinsic('%Math.max%');
|
|
|
|
module.exports = function callBind(originalFunction) {
|
|
if (typeof originalFunction !== 'function') {
|
|
throw new $TypeError('a function is required');
|
|
}
|
|
var func = $reflectApply(bind, $call, arguments);
|
|
return setFunctionLength(
|
|
func,
|
|
1 + $max(0, originalFunction.length - (arguments.length - 1)),
|
|
true
|
|
);
|
|
};
|
|
|
|
var applyBind = function applyBind() {
|
|
return $reflectApply(bind, $apply, arguments);
|
|
};
|
|
|
|
if ($defineProperty) {
|
|
$defineProperty(module.exports, 'apply', { value: applyBind });
|
|
} else {
|
|
module.exports.apply = applyBind;
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4364:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
/*global window, global*/
|
|
var util = __webpack_require__(6827)
|
|
var assert = __webpack_require__(6093)
|
|
function now() { return new Date().getTime() }
|
|
|
|
var slice = Array.prototype.slice
|
|
var console
|
|
var times = {}
|
|
|
|
if (typeof __webpack_require__.g !== "undefined" && __webpack_require__.g.console) {
|
|
console = __webpack_require__.g.console
|
|
} else if (typeof window !== "undefined" && window.console) {
|
|
console = window.console
|
|
} else {
|
|
console = {}
|
|
}
|
|
|
|
var functions = [
|
|
[log, "log"],
|
|
[info, "info"],
|
|
[warn, "warn"],
|
|
[error, "error"],
|
|
[time, "time"],
|
|
[timeEnd, "timeEnd"],
|
|
[trace, "trace"],
|
|
[dir, "dir"],
|
|
[consoleAssert, "assert"]
|
|
]
|
|
|
|
for (var i = 0; i < functions.length; i++) {
|
|
var tuple = functions[i]
|
|
var f = tuple[0]
|
|
var name = tuple[1]
|
|
|
|
if (!console[name]) {
|
|
console[name] = f
|
|
}
|
|
}
|
|
|
|
module.exports = console
|
|
|
|
function log() {}
|
|
|
|
function info() {
|
|
console.log.apply(console, arguments)
|
|
}
|
|
|
|
function warn() {
|
|
console.log.apply(console, arguments)
|
|
}
|
|
|
|
function error() {
|
|
console.warn.apply(console, arguments)
|
|
}
|
|
|
|
function time(label) {
|
|
times[label] = now()
|
|
}
|
|
|
|
function timeEnd(label) {
|
|
var time = times[label]
|
|
if (!time) {
|
|
throw new Error("No such label: " + label)
|
|
}
|
|
|
|
delete times[label]
|
|
var duration = now() - time
|
|
console.log(label + ": " + duration + "ms")
|
|
}
|
|
|
|
function trace() {
|
|
var err = new Error()
|
|
err.name = "Trace"
|
|
err.message = util.format.apply(null, arguments)
|
|
console.error(err.stack)
|
|
}
|
|
|
|
function dir(object) {
|
|
console.log(util.inspect(object) + "\n")
|
|
}
|
|
|
|
function consoleAssert(expression) {
|
|
if (!expression) {
|
|
var arr = slice.call(arguments, 1)
|
|
assert.ok(false, util.format.apply(null, arr))
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 686:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var $defineProperty = __webpack_require__(4940);
|
|
|
|
var $SyntaxError = __webpack_require__(5731);
|
|
var $TypeError = __webpack_require__(3468);
|
|
|
|
var gopd = __webpack_require__(9336);
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function defineDataProperty(
|
|
obj,
|
|
property,
|
|
value
|
|
) {
|
|
if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
|
throw new $TypeError('`obj` must be an object or a function`');
|
|
}
|
|
if (typeof property !== 'string' && typeof property !== 'symbol') {
|
|
throw new $TypeError('`property` must be a string or a symbol`');
|
|
}
|
|
if (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) {
|
|
throw new $TypeError('`nonEnumerable`, if provided, must be a boolean or null');
|
|
}
|
|
if (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) {
|
|
throw new $TypeError('`nonWritable`, if provided, must be a boolean or null');
|
|
}
|
|
if (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) {
|
|
throw new $TypeError('`nonConfigurable`, if provided, must be a boolean or null');
|
|
}
|
|
if (arguments.length > 6 && typeof arguments[6] !== 'boolean') {
|
|
throw new $TypeError('`loose`, if provided, must be a boolean');
|
|
}
|
|
|
|
var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
|
|
var nonWritable = arguments.length > 4 ? arguments[4] : null;
|
|
var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
|
|
var loose = arguments.length > 6 ? arguments[6] : false;
|
|
|
|
/* @type {false | TypedPropertyDescriptor<unknown>} */
|
|
var desc = !!gopd && gopd(obj, property);
|
|
|
|
if ($defineProperty) {
|
|
$defineProperty(obj, property, {
|
|
configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
|
|
enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
|
|
value: value,
|
|
writable: nonWritable === null && desc ? desc.writable : !nonWritable
|
|
});
|
|
} else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) {
|
|
// must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable
|
|
obj[property] = value; // eslint-disable-line no-param-reassign
|
|
} else {
|
|
throw new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.');
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1857:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var keys = __webpack_require__(9228);
|
|
var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
|
|
|
|
var toStr = Object.prototype.toString;
|
|
var concat = Array.prototype.concat;
|
|
var origDefineProperty = Object.defineProperty;
|
|
|
|
var isFunction = function (fn) {
|
|
return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
|
|
};
|
|
|
|
var hasPropertyDescriptors = __webpack_require__(7239)();
|
|
|
|
var supportsDescriptors = origDefineProperty && hasPropertyDescriptors;
|
|
|
|
var defineProperty = function (object, name, value, predicate) {
|
|
if (name in object) {
|
|
if (predicate === true) {
|
|
if (object[name] === value) {
|
|
return;
|
|
}
|
|
} else if (!isFunction(predicate) || !predicate()) {
|
|
return;
|
|
}
|
|
}
|
|
if (supportsDescriptors) {
|
|
origDefineProperty(object, name, {
|
|
configurable: true,
|
|
enumerable: false,
|
|
value: value,
|
|
writable: true
|
|
});
|
|
} else {
|
|
object[name] = value; // eslint-disable-line no-param-reassign
|
|
}
|
|
};
|
|
|
|
var defineProperties = function (object, map) {
|
|
var predicates = arguments.length > 2 ? arguments[2] : {};
|
|
var props = keys(map);
|
|
if (hasSymbols) {
|
|
props = concat.call(props, Object.getOwnPropertySymbols(map));
|
|
}
|
|
for (var i = 0; i < props.length; i += 1) {
|
|
defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
|
|
}
|
|
};
|
|
|
|
defineProperties.supportsDescriptors = !!supportsDescriptors;
|
|
|
|
module.exports = defineProperties;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4940:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var GetIntrinsic = __webpack_require__(528);
|
|
|
|
/** @type {import('.')} */
|
|
var $defineProperty = GetIntrinsic('%Object.defineProperty%', true) || false;
|
|
if ($defineProperty) {
|
|
try {
|
|
$defineProperty({}, 'a', { value: 1 });
|
|
} catch (e) {
|
|
// IE 8 has a broken defineProperty
|
|
$defineProperty = false;
|
|
}
|
|
}
|
|
|
|
module.exports = $defineProperty;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6729:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
/** @type {import('./eval')} */
|
|
module.exports = EvalError;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9838:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = Error;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1155:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
/** @type {import('./range')} */
|
|
module.exports = RangeError;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4943:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
/** @type {import('./ref')} */
|
|
module.exports = ReferenceError;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5731:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
/** @type {import('./syntax')} */
|
|
module.exports = SyntaxError;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3468:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
/** @type {import('./type')} */
|
|
module.exports = TypeError;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2140:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
/** @type {import('./uri')} */
|
|
module.exports = URIError;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3046:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
/**
|
|
* Code refactored from Mozilla Developer Network:
|
|
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
|
|
*/
|
|
|
|
|
|
|
|
function assign(target, firstSource) {
|
|
if (target === undefined || target === null) {
|
|
throw new TypeError('Cannot convert first argument to object');
|
|
}
|
|
|
|
var to = Object(target);
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var nextSource = arguments[i];
|
|
if (nextSource === undefined || nextSource === null) {
|
|
continue;
|
|
}
|
|
|
|
var keysArray = Object.keys(Object(nextSource));
|
|
for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
|
|
var nextKey = keysArray[nextIndex];
|
|
var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
|
|
if (desc !== undefined && desc.enumerable) {
|
|
to[nextKey] = nextSource[nextKey];
|
|
}
|
|
}
|
|
}
|
|
return to;
|
|
}
|
|
|
|
function polyfill() {
|
|
if (!Object.assign) {
|
|
Object.defineProperty(Object, 'assign', {
|
|
enumerable: false,
|
|
configurable: true,
|
|
writable: true,
|
|
value: assign
|
|
});
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
assign: assign,
|
|
polyfill: polyfill
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 705:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var isCallable = __webpack_require__(9617);
|
|
|
|
var toStr = Object.prototype.toString;
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
|
|
var forEachArray = function forEachArray(array, iterator, receiver) {
|
|
for (var i = 0, len = array.length; i < len; i++) {
|
|
if (hasOwnProperty.call(array, i)) {
|
|
if (receiver == null) {
|
|
iterator(array[i], i, array);
|
|
} else {
|
|
iterator.call(receiver, array[i], i, array);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
var forEachString = function forEachString(string, iterator, receiver) {
|
|
for (var i = 0, len = string.length; i < len; i++) {
|
|
// no such thing as a sparse string.
|
|
if (receiver == null) {
|
|
iterator(string.charAt(i), i, string);
|
|
} else {
|
|
iterator.call(receiver, string.charAt(i), i, string);
|
|
}
|
|
}
|
|
};
|
|
|
|
var forEachObject = function forEachObject(object, iterator, receiver) {
|
|
for (var k in object) {
|
|
if (hasOwnProperty.call(object, k)) {
|
|
if (receiver == null) {
|
|
iterator(object[k], k, object);
|
|
} else {
|
|
iterator.call(receiver, object[k], k, object);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
var forEach = function forEach(list, iterator, thisArg) {
|
|
if (!isCallable(iterator)) {
|
|
throw new TypeError('iterator must be a function');
|
|
}
|
|
|
|
var receiver;
|
|
if (arguments.length >= 3) {
|
|
receiver = thisArg;
|
|
}
|
|
|
|
if (toStr.call(list) === '[object Array]') {
|
|
forEachArray(list, iterator, receiver);
|
|
} else if (typeof list === 'string') {
|
|
forEachString(list, iterator, receiver);
|
|
} else {
|
|
forEachObject(list, iterator, receiver);
|
|
}
|
|
};
|
|
|
|
module.exports = forEach;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8794:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
/* eslint no-invalid-this: 1 */
|
|
|
|
var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
|
|
var toStr = Object.prototype.toString;
|
|
var max = Math.max;
|
|
var funcType = '[object Function]';
|
|
|
|
var concatty = function concatty(a, b) {
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < a.length; i += 1) {
|
|
arr[i] = a[i];
|
|
}
|
|
for (var j = 0; j < b.length; j += 1) {
|
|
arr[j + a.length] = b[j];
|
|
}
|
|
|
|
return arr;
|
|
};
|
|
|
|
var slicy = function slicy(arrLike, offset) {
|
|
var arr = [];
|
|
for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
|
|
arr[j] = arrLike[i];
|
|
}
|
|
return arr;
|
|
};
|
|
|
|
var joiny = function (arr, joiner) {
|
|
var str = '';
|
|
for (var i = 0; i < arr.length; i += 1) {
|
|
str += arr[i];
|
|
if (i + 1 < arr.length) {
|
|
str += joiner;
|
|
}
|
|
}
|
|
return str;
|
|
};
|
|
|
|
module.exports = function bind(that) {
|
|
var target = this;
|
|
if (typeof target !== 'function' || toStr.apply(target) !== funcType) {
|
|
throw new TypeError(ERROR_MESSAGE + target);
|
|
}
|
|
var args = slicy(arguments, 1);
|
|
|
|
var bound;
|
|
var binder = function () {
|
|
if (this instanceof bound) {
|
|
var result = target.apply(
|
|
this,
|
|
concatty(args, arguments)
|
|
);
|
|
if (Object(result) === result) {
|
|
return result;
|
|
}
|
|
return this;
|
|
}
|
|
return target.apply(
|
|
that,
|
|
concatty(args, arguments)
|
|
);
|
|
|
|
};
|
|
|
|
var boundLength = max(0, target.length - args.length);
|
|
var boundArgs = [];
|
|
for (var i = 0; i < boundLength; i++) {
|
|
boundArgs[i] = '$' + i;
|
|
}
|
|
|
|
bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);
|
|
|
|
if (target.prototype) {
|
|
var Empty = function Empty() {};
|
|
Empty.prototype = target.prototype;
|
|
bound.prototype = new Empty();
|
|
Empty.prototype = null;
|
|
}
|
|
|
|
return bound;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9138:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var implementation = __webpack_require__(8794);
|
|
|
|
module.exports = Function.prototype.bind || implementation;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 528:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var undefined;
|
|
|
|
var $Error = __webpack_require__(9838);
|
|
var $EvalError = __webpack_require__(6729);
|
|
var $RangeError = __webpack_require__(1155);
|
|
var $ReferenceError = __webpack_require__(4943);
|
|
var $SyntaxError = __webpack_require__(5731);
|
|
var $TypeError = __webpack_require__(3468);
|
|
var $URIError = __webpack_require__(2140);
|
|
|
|
var $Function = Function;
|
|
|
|
// eslint-disable-next-line consistent-return
|
|
var getEvalledConstructor = function (expressionSyntax) {
|
|
try {
|
|
return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
|
|
} catch (e) {}
|
|
};
|
|
|
|
var $gOPD = Object.getOwnPropertyDescriptor;
|
|
if ($gOPD) {
|
|
try {
|
|
$gOPD({}, '');
|
|
} catch (e) {
|
|
$gOPD = null; // this is IE 8, which has a broken gOPD
|
|
}
|
|
}
|
|
|
|
var throwTypeError = function () {
|
|
throw new $TypeError();
|
|
};
|
|
var ThrowTypeError = $gOPD
|
|
? (function () {
|
|
try {
|
|
// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
|
|
arguments.callee; // IE 8 does not throw here
|
|
return throwTypeError;
|
|
} catch (calleeThrows) {
|
|
try {
|
|
// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
|
|
return $gOPD(arguments, 'callee').get;
|
|
} catch (gOPDthrows) {
|
|
return throwTypeError;
|
|
}
|
|
}
|
|
}())
|
|
: throwTypeError;
|
|
|
|
var hasSymbols = __webpack_require__(3558)();
|
|
var hasProto = __webpack_require__(6869)();
|
|
|
|
var getProto = Object.getPrototypeOf || (
|
|
hasProto
|
|
? function (x) { return x.__proto__; } // eslint-disable-line no-proto
|
|
: null
|
|
);
|
|
|
|
var needsEval = {};
|
|
|
|
var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array);
|
|
|
|
var INTRINSICS = {
|
|
__proto__: null,
|
|
'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
|
|
'%Array%': Array,
|
|
'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
|
|
'%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined,
|
|
'%AsyncFromSyncIteratorPrototype%': undefined,
|
|
'%AsyncFunction%': needsEval,
|
|
'%AsyncGenerator%': needsEval,
|
|
'%AsyncGeneratorFunction%': needsEval,
|
|
'%AsyncIteratorPrototype%': needsEval,
|
|
'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
|
|
'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
|
|
'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,
|
|
'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,
|
|
'%Boolean%': Boolean,
|
|
'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
|
|
'%Date%': Date,
|
|
'%decodeURI%': decodeURI,
|
|
'%decodeURIComponent%': decodeURIComponent,
|
|
'%encodeURI%': encodeURI,
|
|
'%encodeURIComponent%': encodeURIComponent,
|
|
'%Error%': $Error,
|
|
'%eval%': eval, // eslint-disable-line no-eval
|
|
'%EvalError%': $EvalError,
|
|
'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
|
|
'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
|
|
'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
|
|
'%Function%': $Function,
|
|
'%GeneratorFunction%': needsEval,
|
|
'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
|
|
'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
|
|
'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
|
|
'%isFinite%': isFinite,
|
|
'%isNaN%': isNaN,
|
|
'%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined,
|
|
'%JSON%': typeof JSON === 'object' ? JSON : undefined,
|
|
'%Map%': typeof Map === 'undefined' ? undefined : Map,
|
|
'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()),
|
|
'%Math%': Math,
|
|
'%Number%': Number,
|
|
'%Object%': Object,
|
|
'%parseFloat%': parseFloat,
|
|
'%parseInt%': parseInt,
|
|
'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
|
|
'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
|
|
'%RangeError%': $RangeError,
|
|
'%ReferenceError%': $ReferenceError,
|
|
'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
|
|
'%RegExp%': RegExp,
|
|
'%Set%': typeof Set === 'undefined' ? undefined : Set,
|
|
'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()),
|
|
'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
|
|
'%String%': String,
|
|
'%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined,
|
|
'%Symbol%': hasSymbols ? Symbol : undefined,
|
|
'%SyntaxError%': $SyntaxError,
|
|
'%ThrowTypeError%': ThrowTypeError,
|
|
'%TypedArray%': TypedArray,
|
|
'%TypeError%': $TypeError,
|
|
'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
|
|
'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
|
|
'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
|
|
'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
|
|
'%URIError%': $URIError,
|
|
'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
|
|
'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
|
|
'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet
|
|
};
|
|
|
|
if (getProto) {
|
|
try {
|
|
null.error; // eslint-disable-line no-unused-expressions
|
|
} catch (e) {
|
|
// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
|
|
var errorProto = getProto(getProto(e));
|
|
INTRINSICS['%Error.prototype%'] = errorProto;
|
|
}
|
|
}
|
|
|
|
var doEval = function doEval(name) {
|
|
var value;
|
|
if (name === '%AsyncFunction%') {
|
|
value = getEvalledConstructor('async function () {}');
|
|
} else if (name === '%GeneratorFunction%') {
|
|
value = getEvalledConstructor('function* () {}');
|
|
} else if (name === '%AsyncGeneratorFunction%') {
|
|
value = getEvalledConstructor('async function* () {}');
|
|
} else if (name === '%AsyncGenerator%') {
|
|
var fn = doEval('%AsyncGeneratorFunction%');
|
|
if (fn) {
|
|
value = fn.prototype;
|
|
}
|
|
} else if (name === '%AsyncIteratorPrototype%') {
|
|
var gen = doEval('%AsyncGenerator%');
|
|
if (gen && getProto) {
|
|
value = getProto(gen.prototype);
|
|
}
|
|
}
|
|
|
|
INTRINSICS[name] = value;
|
|
|
|
return value;
|
|
};
|
|
|
|
var LEGACY_ALIASES = {
|
|
__proto__: null,
|
|
'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
|
|
'%ArrayPrototype%': ['Array', 'prototype'],
|
|
'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
|
|
'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
|
|
'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
|
|
'%ArrayProto_values%': ['Array', 'prototype', 'values'],
|
|
'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
|
|
'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
|
|
'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
|
|
'%BooleanPrototype%': ['Boolean', 'prototype'],
|
|
'%DataViewPrototype%': ['DataView', 'prototype'],
|
|
'%DatePrototype%': ['Date', 'prototype'],
|
|
'%ErrorPrototype%': ['Error', 'prototype'],
|
|
'%EvalErrorPrototype%': ['EvalError', 'prototype'],
|
|
'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
|
|
'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
|
|
'%FunctionPrototype%': ['Function', 'prototype'],
|
|
'%Generator%': ['GeneratorFunction', 'prototype'],
|
|
'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
|
|
'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
|
|
'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
|
|
'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
|
|
'%JSONParse%': ['JSON', 'parse'],
|
|
'%JSONStringify%': ['JSON', 'stringify'],
|
|
'%MapPrototype%': ['Map', 'prototype'],
|
|
'%NumberPrototype%': ['Number', 'prototype'],
|
|
'%ObjectPrototype%': ['Object', 'prototype'],
|
|
'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
|
|
'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
|
|
'%PromisePrototype%': ['Promise', 'prototype'],
|
|
'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
|
|
'%Promise_all%': ['Promise', 'all'],
|
|
'%Promise_reject%': ['Promise', 'reject'],
|
|
'%Promise_resolve%': ['Promise', 'resolve'],
|
|
'%RangeErrorPrototype%': ['RangeError', 'prototype'],
|
|
'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
|
|
'%RegExpPrototype%': ['RegExp', 'prototype'],
|
|
'%SetPrototype%': ['Set', 'prototype'],
|
|
'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
|
|
'%StringPrototype%': ['String', 'prototype'],
|
|
'%SymbolPrototype%': ['Symbol', 'prototype'],
|
|
'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
|
|
'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
|
|
'%TypeErrorPrototype%': ['TypeError', 'prototype'],
|
|
'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
|
|
'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
|
|
'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
|
|
'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
|
|
'%URIErrorPrototype%': ['URIError', 'prototype'],
|
|
'%WeakMapPrototype%': ['WeakMap', 'prototype'],
|
|
'%WeakSetPrototype%': ['WeakSet', 'prototype']
|
|
};
|
|
|
|
var bind = __webpack_require__(9138);
|
|
var hasOwn = __webpack_require__(8554);
|
|
var $concat = bind.call(Function.call, Array.prototype.concat);
|
|
var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
|
|
var $replace = bind.call(Function.call, String.prototype.replace);
|
|
var $strSlice = bind.call(Function.call, String.prototype.slice);
|
|
var $exec = bind.call(Function.call, RegExp.prototype.exec);
|
|
|
|
/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
|
|
var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
|
|
var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
|
|
var stringToPath = function stringToPath(string) {
|
|
var first = $strSlice(string, 0, 1);
|
|
var last = $strSlice(string, -1);
|
|
if (first === '%' && last !== '%') {
|
|
throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
|
|
} else if (last === '%' && first !== '%') {
|
|
throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
|
|
}
|
|
var result = [];
|
|
$replace(string, rePropName, function (match, number, quote, subString) {
|
|
result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
|
|
});
|
|
return result;
|
|
};
|
|
/* end adaptation */
|
|
|
|
var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
|
|
var intrinsicName = name;
|
|
var alias;
|
|
if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
|
|
alias = LEGACY_ALIASES[intrinsicName];
|
|
intrinsicName = '%' + alias[0] + '%';
|
|
}
|
|
|
|
if (hasOwn(INTRINSICS, intrinsicName)) {
|
|
var value = INTRINSICS[intrinsicName];
|
|
if (value === needsEval) {
|
|
value = doEval(intrinsicName);
|
|
}
|
|
if (typeof value === 'undefined' && !allowMissing) {
|
|
throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
|
|
}
|
|
|
|
return {
|
|
alias: alias,
|
|
name: intrinsicName,
|
|
value: value
|
|
};
|
|
}
|
|
|
|
throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
|
|
};
|
|
|
|
module.exports = function GetIntrinsic(name, allowMissing) {
|
|
if (typeof name !== 'string' || name.length === 0) {
|
|
throw new $TypeError('intrinsic name must be a non-empty string');
|
|
}
|
|
if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
|
|
throw new $TypeError('"allowMissing" argument must be a boolean');
|
|
}
|
|
|
|
if ($exec(/^%?[^%]*%?$/, name) === null) {
|
|
throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');
|
|
}
|
|
var parts = stringToPath(name);
|
|
var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
|
|
|
|
var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
|
|
var intrinsicRealName = intrinsic.name;
|
|
var value = intrinsic.value;
|
|
var skipFurtherCaching = false;
|
|
|
|
var alias = intrinsic.alias;
|
|
if (alias) {
|
|
intrinsicBaseName = alias[0];
|
|
$spliceApply(parts, $concat([0, 1], alias));
|
|
}
|
|
|
|
for (var i = 1, isOwn = true; i < parts.length; i += 1) {
|
|
var part = parts[i];
|
|
var first = $strSlice(part, 0, 1);
|
|
var last = $strSlice(part, -1);
|
|
if (
|
|
(
|
|
(first === '"' || first === "'" || first === '`')
|
|
|| (last === '"' || last === "'" || last === '`')
|
|
)
|
|
&& first !== last
|
|
) {
|
|
throw new $SyntaxError('property names with quotes must have matching quotes');
|
|
}
|
|
if (part === 'constructor' || !isOwn) {
|
|
skipFurtherCaching = true;
|
|
}
|
|
|
|
intrinsicBaseName += '.' + part;
|
|
intrinsicRealName = '%' + intrinsicBaseName + '%';
|
|
|
|
if (hasOwn(INTRINSICS, intrinsicRealName)) {
|
|
value = INTRINSICS[intrinsicRealName];
|
|
} else if (value != null) {
|
|
if (!(part in value)) {
|
|
if (!allowMissing) {
|
|
throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
|
|
}
|
|
return void undefined;
|
|
}
|
|
if ($gOPD && (i + 1) >= parts.length) {
|
|
var desc = $gOPD(value, part);
|
|
isOwn = !!desc;
|
|
|
|
// By convention, when a data property is converted to an accessor
|
|
// property to emulate a data property that does not suffer from
|
|
// the override mistake, that accessor's getter is marked with
|
|
// an `originalValue` property. Here, when we detect this, we
|
|
// uphold the illusion by pretending to see that original data
|
|
// property, i.e., returning the value rather than the getter
|
|
// itself.
|
|
if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
|
|
value = desc.get;
|
|
} else {
|
|
value = value[part];
|
|
}
|
|
} else {
|
|
isOwn = hasOwn(value, part);
|
|
value = value[part];
|
|
}
|
|
|
|
if (isOwn && !skipFurtherCaching) {
|
|
INTRINSICS[intrinsicRealName] = value;
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9336:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var GetIntrinsic = __webpack_require__(528);
|
|
|
|
var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);
|
|
|
|
if ($gOPD) {
|
|
try {
|
|
$gOPD([], 'length');
|
|
} catch (e) {
|
|
// IE 8 has a broken gOPD
|
|
$gOPD = null;
|
|
}
|
|
}
|
|
|
|
module.exports = $gOPD;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7239:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var $defineProperty = __webpack_require__(4940);
|
|
|
|
var hasPropertyDescriptors = function hasPropertyDescriptors() {
|
|
return !!$defineProperty;
|
|
};
|
|
|
|
hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
|
|
// node v0.6 has a bug where array lengths can be Set but not Defined
|
|
if (!$defineProperty) {
|
|
return null;
|
|
}
|
|
try {
|
|
return $defineProperty([], 'length', { value: 1 }).length !== 1;
|
|
} catch (e) {
|
|
// In Firefox 4-22, defining length on an array throws an exception.
|
|
return true;
|
|
}
|
|
};
|
|
|
|
module.exports = hasPropertyDescriptors;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6869:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var test = {
|
|
foo: {}
|
|
};
|
|
|
|
var $Object = Object;
|
|
|
|
module.exports = function hasProto() {
|
|
return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3558:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var origSymbol = typeof Symbol !== 'undefined' && Symbol;
|
|
var hasSymbolSham = __webpack_require__(2908);
|
|
|
|
module.exports = function hasNativeSymbols() {
|
|
if (typeof origSymbol !== 'function') { return false; }
|
|
if (typeof Symbol !== 'function') { return false; }
|
|
if (typeof origSymbol('foo') !== 'symbol') { return false; }
|
|
if (typeof Symbol('bar') !== 'symbol') { return false; }
|
|
|
|
return hasSymbolSham();
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2908:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
/* eslint complexity: [2, 18], max-statements: [2, 33] */
|
|
module.exports = function hasSymbols() {
|
|
if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
|
|
if (typeof Symbol.iterator === 'symbol') { return true; }
|
|
|
|
var obj = {};
|
|
var sym = Symbol('test');
|
|
var symObj = Object(sym);
|
|
if (typeof sym === 'string') { return false; }
|
|
|
|
if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
|
|
if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
|
|
|
|
// temp disabled per https://github.com/ljharb/object.assign/issues/17
|
|
// if (sym instanceof Symbol) { return false; }
|
|
// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
|
|
// if (!(symObj instanceof Symbol)) { return false; }
|
|
|
|
// if (typeof Symbol.prototype.toString !== 'function') { return false; }
|
|
// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
|
|
|
|
var symVal = 42;
|
|
obj[sym] = symVal;
|
|
for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
|
|
if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
|
|
|
|
if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
|
|
|
|
var syms = Object.getOwnPropertySymbols(obj);
|
|
if (syms.length !== 1 || syms[0] !== sym) { return false; }
|
|
|
|
if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
|
|
|
|
if (typeof Object.getOwnPropertyDescriptor === 'function') {
|
|
var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
|
|
if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1913:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var hasSymbols = __webpack_require__(2908);
|
|
|
|
module.exports = function hasToStringTagShams() {
|
|
return hasSymbols() && !!Symbol.toStringTag;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8554:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var call = Function.prototype.call;
|
|
var $hasOwn = Object.prototype.hasOwnProperty;
|
|
var bind = __webpack_require__(9138);
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = bind.call(call, $hasOwn);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5615:
|
|
/***/ ((module) => {
|
|
|
|
if (typeof Object.create === 'function') {
|
|
// implementation from standard node.js 'util' module
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
})
|
|
}
|
|
};
|
|
} else {
|
|
// old school shim for old browsers
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor
|
|
var TempCtor = function () {}
|
|
TempCtor.prototype = superCtor.prototype
|
|
ctor.prototype = new TempCtor()
|
|
ctor.prototype.constructor = ctor
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5387:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var hasToStringTag = __webpack_require__(1913)();
|
|
var callBound = __webpack_require__(9818);
|
|
|
|
var $toString = callBound('Object.prototype.toString');
|
|
|
|
var isStandardArguments = function isArguments(value) {
|
|
if (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {
|
|
return false;
|
|
}
|
|
return $toString(value) === '[object Arguments]';
|
|
};
|
|
|
|
var isLegacyArguments = function isArguments(value) {
|
|
if (isStandardArguments(value)) {
|
|
return true;
|
|
}
|
|
return value !== null &&
|
|
typeof value === 'object' &&
|
|
typeof value.length === 'number' &&
|
|
value.length >= 0 &&
|
|
$toString(value) !== '[object Array]' &&
|
|
$toString(value.callee) === '[object Function]';
|
|
};
|
|
|
|
var supportsStandardArguments = (function () {
|
|
return isStandardArguments(arguments);
|
|
}());
|
|
|
|
isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests
|
|
|
|
module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9617:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var fnToStr = Function.prototype.toString;
|
|
var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;
|
|
var badArrayLike;
|
|
var isCallableMarker;
|
|
if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {
|
|
try {
|
|
badArrayLike = Object.defineProperty({}, 'length', {
|
|
get: function () {
|
|
throw isCallableMarker;
|
|
}
|
|
});
|
|
isCallableMarker = {};
|
|
// eslint-disable-next-line no-throw-literal
|
|
reflectApply(function () { throw 42; }, null, badArrayLike);
|
|
} catch (_) {
|
|
if (_ !== isCallableMarker) {
|
|
reflectApply = null;
|
|
}
|
|
}
|
|
} else {
|
|
reflectApply = null;
|
|
}
|
|
|
|
var constructorRegex = /^\s*class\b/;
|
|
var isES6ClassFn = function isES6ClassFunction(value) {
|
|
try {
|
|
var fnStr = fnToStr.call(value);
|
|
return constructorRegex.test(fnStr);
|
|
} catch (e) {
|
|
return false; // not a function
|
|
}
|
|
};
|
|
|
|
var tryFunctionObject = function tryFunctionToStr(value) {
|
|
try {
|
|
if (isES6ClassFn(value)) { return false; }
|
|
fnToStr.call(value);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
var toStr = Object.prototype.toString;
|
|
var objectClass = '[object Object]';
|
|
var fnClass = '[object Function]';
|
|
var genClass = '[object GeneratorFunction]';
|
|
var ddaClass = '[object HTMLAllCollection]'; // IE 11
|
|
var ddaClass2 = '[object HTML document.all class]';
|
|
var ddaClass3 = '[object HTMLCollection]'; // IE 9-10
|
|
var hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`
|
|
|
|
var isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing
|
|
|
|
var isDDA = function isDocumentDotAll() { return false; };
|
|
if (typeof document === 'object') {
|
|
// Firefox 3 canonicalizes DDA to undefined when it's not accessed directly
|
|
var all = document.all;
|
|
if (toStr.call(all) === toStr.call(document.all)) {
|
|
isDDA = function isDocumentDotAll(value) {
|
|
/* globals document: false */
|
|
// in IE 6-8, typeof document.all is "object" and it's truthy
|
|
if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {
|
|
try {
|
|
var str = toStr.call(value);
|
|
return (
|
|
str === ddaClass
|
|
|| str === ddaClass2
|
|
|| str === ddaClass3 // opera 12.16
|
|
|| str === objectClass // IE 6-8
|
|
) && value('') == null; // eslint-disable-line eqeqeq
|
|
} catch (e) { /**/ }
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
}
|
|
|
|
module.exports = reflectApply
|
|
? function isCallable(value) {
|
|
if (isDDA(value)) { return true; }
|
|
if (!value) { return false; }
|
|
if (typeof value !== 'function' && typeof value !== 'object') { return false; }
|
|
try {
|
|
reflectApply(value, null, badArrayLike);
|
|
} catch (e) {
|
|
if (e !== isCallableMarker) { return false; }
|
|
}
|
|
return !isES6ClassFn(value) && tryFunctionObject(value);
|
|
}
|
|
: function isCallable(value) {
|
|
if (isDDA(value)) { return true; }
|
|
if (!value) { return false; }
|
|
if (typeof value !== 'function' && typeof value !== 'object') { return false; }
|
|
if (hasToStringTag) { return tryFunctionObject(value); }
|
|
if (isES6ClassFn(value)) { return false; }
|
|
var strClass = toStr.call(value);
|
|
if (strClass !== fnClass && strClass !== genClass && !(/^\[object HTML/).test(strClass)) { return false; }
|
|
return tryFunctionObject(value);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2625:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var toStr = Object.prototype.toString;
|
|
var fnToStr = Function.prototype.toString;
|
|
var isFnRegex = /^\s*(?:function)?\*/;
|
|
var hasToStringTag = __webpack_require__(1913)();
|
|
var getProto = Object.getPrototypeOf;
|
|
var getGeneratorFunc = function () { // eslint-disable-line consistent-return
|
|
if (!hasToStringTag) {
|
|
return false;
|
|
}
|
|
try {
|
|
return Function('return function*() {}')();
|
|
} catch (e) {
|
|
}
|
|
};
|
|
var GeneratorFunction;
|
|
|
|
module.exports = function isGeneratorFunction(fn) {
|
|
if (typeof fn !== 'function') {
|
|
return false;
|
|
}
|
|
if (isFnRegex.test(fnToStr.call(fn))) {
|
|
return true;
|
|
}
|
|
if (!hasToStringTag) {
|
|
var str = toStr.call(fn);
|
|
return str === '[object GeneratorFunction]';
|
|
}
|
|
if (!getProto) {
|
|
return false;
|
|
}
|
|
if (typeof GeneratorFunction === 'undefined') {
|
|
var generatorFunc = getGeneratorFunc();
|
|
GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;
|
|
}
|
|
return getProto(fn) === GeneratorFunction;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8006:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */
|
|
|
|
module.exports = function isNaN(value) {
|
|
return value !== value;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7838:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var callBind = __webpack_require__(8498);
|
|
var define = __webpack_require__(1857);
|
|
|
|
var implementation = __webpack_require__(8006);
|
|
var getPolyfill = __webpack_require__(1591);
|
|
var shim = __webpack_require__(1641);
|
|
|
|
var polyfill = callBind(getPolyfill(), Number);
|
|
|
|
/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */
|
|
|
|
define(polyfill, {
|
|
getPolyfill: getPolyfill,
|
|
implementation: implementation,
|
|
shim: shim
|
|
});
|
|
|
|
module.exports = polyfill;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1591:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var implementation = __webpack_require__(8006);
|
|
|
|
module.exports = function getPolyfill() {
|
|
if (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN('a')) {
|
|
return Number.isNaN;
|
|
}
|
|
return implementation;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1641:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var define = __webpack_require__(1857);
|
|
var getPolyfill = __webpack_require__(1591);
|
|
|
|
/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */
|
|
|
|
module.exports = function shimNumberIsNaN() {
|
|
var polyfill = getPolyfill();
|
|
define(Number, { isNaN: polyfill }, {
|
|
isNaN: function testIsNaN() {
|
|
return Number.isNaN !== polyfill;
|
|
}
|
|
});
|
|
return polyfill;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5943:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var whichTypedArray = __webpack_require__(2730);
|
|
|
|
module.exports = function isTypedArray(value) {
|
|
return !!whichTypedArray(value);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 98:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/* module decorator */ module = __webpack_require__.nmd(module);
|
|
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* global exports:true, module:true, require:true, define:true, global:true */
|
|
|
|
(function (root, name, factory) {
|
|
'use strict';
|
|
|
|
// Used to determine if values are of the language type `Object`
|
|
var objectTypes = {
|
|
'function': true
|
|
, 'object': true
|
|
}
|
|
// Detect free variable `exports`
|
|
, freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports
|
|
// Detect free variable `module`
|
|
, freeModule = objectTypes["object"] && module && !module.nodeType && module
|
|
// Detect free variable `global`, from Node.js or Browserified code, and
|
|
// use it as `window`
|
|
, freeGlobal = freeExports && freeModule && typeof __webpack_require__.g === 'object' && __webpack_require__.g
|
|
// Detect the popular CommonJS extension `module.exports`
|
|
, moduleExports = freeModule && freeModule.exports === freeExports && freeExports;
|
|
|
|
/* istanbul ignore else */
|
|
if (freeGlobal && (freeGlobal.global === freeGlobal ||
|
|
/* istanbul ignore next */ freeGlobal.window === freeGlobal ||
|
|
/* istanbul ignore next */ freeGlobal.self === freeGlobal)) {
|
|
root = freeGlobal;
|
|
}
|
|
|
|
// Some AMD build optimizers, like r.js, check for specific condition
|
|
// patterns like the following:
|
|
/* istanbul ignore if */
|
|
if (true) {
|
|
// defined as an anonymous module.
|
|
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
|
|
(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
|
// In case the source has been processed and wrapped in a define module use
|
|
// the supplied `exports` object.
|
|
if (freeExports && moduleExports) factory(freeModule.exports);
|
|
}
|
|
// check for `exports` after `define` in case a build optimizer adds an
|
|
// `exports` object
|
|
else /* istanbul ignore else */ {}
|
|
}(this, 'luaparse', function (exports) {
|
|
'use strict';
|
|
|
|
exports.version = "0.3.1";
|
|
|
|
var input, options, length, features, encodingMode;
|
|
|
|
// Options can be set either globally on the parser object through
|
|
// defaultOptions, or during the parse call.
|
|
var defaultOptions = exports.defaultOptions = {
|
|
// Explicitly tell the parser when the input ends.
|
|
wait: false
|
|
// Store comments as an array in the chunk object.
|
|
, comments: true
|
|
// Track identifier scopes by adding an isLocal attribute to each
|
|
// identifier-node.
|
|
, scope: false
|
|
// Store location information on each syntax node as
|
|
// `loc: { start: { line, column }, end: { line, column } }`.
|
|
, locations: false
|
|
// Store the start and end character locations on each syntax node as
|
|
// `range: [start, end]`.
|
|
, ranges: false
|
|
// A callback which will be invoked when a syntax node has been completed.
|
|
// The node which has been created will be passed as the only parameter.
|
|
, onCreateNode: null
|
|
// A callback which will be invoked when a new scope is created.
|
|
, onCreateScope: null
|
|
// A callback which will be invoked when the current scope is destroyed.
|
|
, onDestroyScope: null
|
|
// A callback which will be invoked when a local variable is declared in the current scope.
|
|
// The variable's name will be passed as the only parameter
|
|
, onLocalDeclaration: null
|
|
// The version of Lua targeted by the parser (string; allowed values are
|
|
// '5.1', '5.2', '5.3').
|
|
, luaVersion: '5.1'
|
|
// Encoding mode: how to interpret code units higher than U+007F in input
|
|
, encodingMode: 'none'
|
|
};
|
|
|
|
function encodeUTF8(codepoint, highMask) {
|
|
highMask = highMask || 0;
|
|
|
|
if (codepoint < 0x80) {
|
|
return String.fromCharCode(codepoint);
|
|
} else if (codepoint < 0x800) {
|
|
return String.fromCharCode(
|
|
highMask | 0xc0 | (codepoint >> 6) ,
|
|
highMask | 0x80 | ( codepoint & 0x3f)
|
|
);
|
|
} else if (codepoint < 0x10000) {
|
|
return String.fromCharCode(
|
|
highMask | 0xe0 | (codepoint >> 12) ,
|
|
highMask | 0x80 | ((codepoint >> 6) & 0x3f),
|
|
highMask | 0x80 | ( codepoint & 0x3f)
|
|
);
|
|
} else /* istanbul ignore else */ if (codepoint < 0x110000) {
|
|
return String.fromCharCode(
|
|
highMask | 0xf0 | (codepoint >> 18) ,
|
|
highMask | 0x80 | ((codepoint >> 12) & 0x3f),
|
|
highMask | 0x80 | ((codepoint >> 6) & 0x3f),
|
|
highMask | 0x80 | ( codepoint & 0x3f)
|
|
);
|
|
} else {
|
|
// TODO: Lua 5.4 allows up to six-byte sequences, as in UTF-8:1993
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function toHex(num, digits) {
|
|
var result = num.toString(16);
|
|
while (result.length < digits)
|
|
result = '0' + result;
|
|
return result;
|
|
}
|
|
|
|
function checkChars(rx) {
|
|
return function (s) {
|
|
var m = rx.exec(s);
|
|
if (!m)
|
|
return s;
|
|
raise(null, errors.invalidCodeUnit, toHex(m[0].charCodeAt(0), 4).toUpperCase());
|
|
};
|
|
}
|
|
|
|
var encodingModes = {
|
|
// `pseudo-latin1` encoding mode: assume the input was decoded with the latin1 encoding
|
|
// WARNING: latin1 does **NOT** mean cp1252 here like in the bone-headed WHATWG standard;
|
|
// it means true ISO/IEC 8859-1 identity-mapped to Basic Latin and Latin-1 Supplement blocks
|
|
'pseudo-latin1': {
|
|
fixup: checkChars(/[^\x00-\xff]/),
|
|
encodeByte: function (value) {
|
|
if (value === null)
|
|
return '';
|
|
return String.fromCharCode(value);
|
|
},
|
|
encodeUTF8: function (codepoint) {
|
|
return encodeUTF8(codepoint);
|
|
},
|
|
},
|
|
|
|
// `x-user-defined` encoding mode: assume the input was decoded with the WHATWG `x-user-defined` encoding
|
|
'x-user-defined': {
|
|
fixup: checkChars(/[^\x00-\x7f\uf780-\uf7ff]/),
|
|
encodeByte: function (value) {
|
|
if (value === null)
|
|
return '';
|
|
if (value >= 0x80)
|
|
return String.fromCharCode(value | 0xf700);
|
|
return String.fromCharCode(value);
|
|
},
|
|
encodeUTF8: function (codepoint) {
|
|
return encodeUTF8(codepoint, 0xf700);
|
|
}
|
|
},
|
|
|
|
// `none` encoding mode: disregard intrepretation of string literals, leave identifiers as-is
|
|
'none': {
|
|
discardStrings: true,
|
|
fixup: function (s) {
|
|
return s;
|
|
},
|
|
encodeByte: function (value) {
|
|
return '';
|
|
},
|
|
encodeUTF8: function (codepoint) {
|
|
return '';
|
|
}
|
|
}
|
|
};
|
|
|
|
// The available tokens expressed as enum flags so they can be checked with
|
|
// bitwise operations.
|
|
|
|
var EOF = 1, StringLiteral = 2, Keyword = 4, Identifier = 8
|
|
, NumericLiteral = 16, Punctuator = 32, BooleanLiteral = 64
|
|
, NilLiteral = 128, VarargLiteral = 256;
|
|
|
|
exports.tokenTypes = { EOF: EOF, StringLiteral: StringLiteral
|
|
, Keyword: Keyword, Identifier: Identifier, NumericLiteral: NumericLiteral
|
|
, Punctuator: Punctuator, BooleanLiteral: BooleanLiteral
|
|
, NilLiteral: NilLiteral, VarargLiteral: VarargLiteral
|
|
};
|
|
|
|
// As this parser is a bit different from luas own, the error messages
|
|
// will be different in some situations.
|
|
|
|
var errors = exports.errors = {
|
|
unexpected: 'unexpected %1 \'%2\' near \'%3\''
|
|
, unexpectedEOF: 'unexpected symbol near \'<eof>\''
|
|
, expected: '\'%1\' expected near \'%2\''
|
|
, expectedToken: '%1 expected near \'%2\''
|
|
, unfinishedString: 'unfinished string near \'%1\''
|
|
, malformedNumber: 'malformed number near \'%1\''
|
|
, decimalEscapeTooLarge: 'decimal escape too large near \'%1\''
|
|
, invalidEscape: 'invalid escape sequence near \'%1\''
|
|
, hexadecimalDigitExpected: 'hexadecimal digit expected near \'%1\''
|
|
, braceExpected: 'missing \'%1\' near \'%2\''
|
|
, tooLargeCodepoint: 'UTF-8 value too large near \'%1\''
|
|
, unfinishedLongString: 'unfinished long string (starting at line %1) near \'%2\''
|
|
, unfinishedLongComment: 'unfinished long comment (starting at line %1) near \'%2\''
|
|
, ambiguousSyntax: 'ambiguous syntax (function call x new statement) near \'%1\''
|
|
, noLoopToBreak: 'no loop to break near \'%1\''
|
|
, labelAlreadyDefined: 'label \'%1\' already defined on line %2'
|
|
, labelNotVisible: 'no visible label \'%1\' for <goto>'
|
|
, gotoJumpInLocalScope: '<goto %1> jumps into the scope of local \'%2\''
|
|
, cannotUseVararg: 'cannot use \'...\' outside a vararg function near \'%1\''
|
|
, invalidCodeUnit: 'code unit U+%1 is not allowed in the current encoding mode'
|
|
};
|
|
|
|
// ### Abstract Syntax Tree
|
|
//
|
|
// The default AST structure is inspired by the Mozilla Parser API but can
|
|
// easily be customized by overriding these functions.
|
|
|
|
var ast = exports.ast = {
|
|
labelStatement: function(label) {
|
|
return {
|
|
type: 'LabelStatement'
|
|
, label: label
|
|
};
|
|
}
|
|
|
|
, breakStatement: function() {
|
|
return {
|
|
type: 'BreakStatement'
|
|
};
|
|
}
|
|
|
|
, gotoStatement: function(label) {
|
|
return {
|
|
type: 'GotoStatement'
|
|
, label: label
|
|
};
|
|
}
|
|
|
|
, returnStatement: function(args) {
|
|
return {
|
|
type: 'ReturnStatement'
|
|
, 'arguments': args
|
|
};
|
|
}
|
|
|
|
, ifStatement: function(clauses) {
|
|
return {
|
|
type: 'IfStatement'
|
|
, clauses: clauses
|
|
};
|
|
}
|
|
, ifClause: function(condition, body) {
|
|
return {
|
|
type: 'IfClause'
|
|
, condition: condition
|
|
, body: body
|
|
};
|
|
}
|
|
, elseifClause: function(condition, body) {
|
|
return {
|
|
type: 'ElseifClause'
|
|
, condition: condition
|
|
, body: body
|
|
};
|
|
}
|
|
, elseClause: function(body) {
|
|
return {
|
|
type: 'ElseClause'
|
|
, body: body
|
|
};
|
|
}
|
|
|
|
, whileStatement: function(condition, body) {
|
|
return {
|
|
type: 'WhileStatement'
|
|
, condition: condition
|
|
, body: body
|
|
};
|
|
}
|
|
|
|
, doStatement: function(body) {
|
|
return {
|
|
type: 'DoStatement'
|
|
, body: body
|
|
};
|
|
}
|
|
|
|
, repeatStatement: function(condition, body) {
|
|
return {
|
|
type: 'RepeatStatement'
|
|
, condition: condition
|
|
, body: body
|
|
};
|
|
}
|
|
|
|
, localStatement: function(variables, init) {
|
|
return {
|
|
type: 'LocalStatement'
|
|
, variables: variables
|
|
, init: init
|
|
};
|
|
}
|
|
|
|
, assignmentStatement: function(variables, init) {
|
|
return {
|
|
type: 'AssignmentStatement'
|
|
, variables: variables
|
|
, init: init
|
|
};
|
|
}
|
|
|
|
, callStatement: function(expression) {
|
|
return {
|
|
type: 'CallStatement'
|
|
, expression: expression
|
|
};
|
|
}
|
|
|
|
, functionStatement: function(identifier, parameters, isLocal, body) {
|
|
return {
|
|
type: 'FunctionDeclaration'
|
|
, identifier: identifier
|
|
, isLocal: isLocal
|
|
, parameters: parameters
|
|
, body: body
|
|
};
|
|
}
|
|
|
|
, forNumericStatement: function(variable, start, end, step, body) {
|
|
return {
|
|
type: 'ForNumericStatement'
|
|
, variable: variable
|
|
, start: start
|
|
, end: end
|
|
, step: step
|
|
, body: body
|
|
};
|
|
}
|
|
|
|
, forGenericStatement: function(variables, iterators, body) {
|
|
return {
|
|
type: 'ForGenericStatement'
|
|
, variables: variables
|
|
, iterators: iterators
|
|
, body: body
|
|
};
|
|
}
|
|
|
|
, chunk: function(body) {
|
|
return {
|
|
type: 'Chunk'
|
|
, body: body
|
|
};
|
|
}
|
|
|
|
, identifier: function(name) {
|
|
return {
|
|
type: 'Identifier'
|
|
, name: name
|
|
};
|
|
}
|
|
|
|
, literal: function(type, value, raw) {
|
|
type = (type === StringLiteral) ? 'StringLiteral'
|
|
: (type === NumericLiteral) ? 'NumericLiteral'
|
|
: (type === BooleanLiteral) ? 'BooleanLiteral'
|
|
: (type === NilLiteral) ? 'NilLiteral'
|
|
: 'VarargLiteral';
|
|
|
|
return {
|
|
type: type
|
|
, value: value
|
|
, raw: raw
|
|
};
|
|
}
|
|
|
|
, tableKey: function(key, value) {
|
|
return {
|
|
type: 'TableKey'
|
|
, key: key
|
|
, value: value
|
|
};
|
|
}
|
|
, tableKeyString: function(key, value) {
|
|
return {
|
|
type: 'TableKeyString'
|
|
, key: key
|
|
, value: value
|
|
};
|
|
}
|
|
, tableValue: function(value) {
|
|
return {
|
|
type: 'TableValue'
|
|
, value: value
|
|
};
|
|
}
|
|
|
|
|
|
, tableConstructorExpression: function(fields) {
|
|
return {
|
|
type: 'TableConstructorExpression'
|
|
, fields: fields
|
|
};
|
|
}
|
|
, binaryExpression: function(operator, left, right) {
|
|
var type = ('and' === operator || 'or' === operator) ?
|
|
'LogicalExpression' :
|
|
'BinaryExpression';
|
|
|
|
return {
|
|
type: type
|
|
, operator: operator
|
|
, left: left
|
|
, right: right
|
|
};
|
|
}
|
|
, unaryExpression: function(operator, argument) {
|
|
return {
|
|
type: 'UnaryExpression'
|
|
, operator: operator
|
|
, argument: argument
|
|
};
|
|
}
|
|
, memberExpression: function(base, indexer, identifier) {
|
|
return {
|
|
type: 'MemberExpression'
|
|
, indexer: indexer
|
|
, identifier: identifier
|
|
, base: base
|
|
};
|
|
}
|
|
|
|
, indexExpression: function(base, index) {
|
|
return {
|
|
type: 'IndexExpression'
|
|
, base: base
|
|
, index: index
|
|
};
|
|
}
|
|
|
|
, callExpression: function(base, args) {
|
|
return {
|
|
type: 'CallExpression'
|
|
, base: base
|
|
, 'arguments': args
|
|
};
|
|
}
|
|
|
|
, tableCallExpression: function(base, args) {
|
|
return {
|
|
type: 'TableCallExpression'
|
|
, base: base
|
|
, 'arguments': args
|
|
};
|
|
}
|
|
|
|
, stringCallExpression: function(base, argument) {
|
|
return {
|
|
type: 'StringCallExpression'
|
|
, base: base
|
|
, argument: argument
|
|
};
|
|
}
|
|
|
|
, comment: function(value, raw) {
|
|
return {
|
|
type: 'Comment'
|
|
, value: value
|
|
, raw: raw
|
|
};
|
|
}
|
|
};
|
|
|
|
// Wrap up the node object.
|
|
|
|
function finishNode(node) {
|
|
// Pop a `Marker` off the location-array and attach its location data.
|
|
if (trackLocations) {
|
|
var location = locations.pop();
|
|
location.complete();
|
|
location.bless(node);
|
|
}
|
|
if (options.onCreateNode) options.onCreateNode(node);
|
|
return node;
|
|
}
|
|
|
|
|
|
// Helpers
|
|
// -------
|
|
|
|
var slice = Array.prototype.slice
|
|
, toString = Object.prototype.toString
|
|
;
|
|
|
|
var indexOf = /* istanbul ignore next */ function (array, element) {
|
|
for (var i = 0, length = array.length; i < length; ++i) {
|
|
if (array[i] === element) return i;
|
|
}
|
|
return -1;
|
|
};
|
|
|
|
/* istanbul ignore else */
|
|
if (Array.prototype.indexOf)
|
|
indexOf = function (array, element) {
|
|
return array.indexOf(element);
|
|
};
|
|
|
|
// Iterate through an array of objects and return the index of an object
|
|
// with a matching property.
|
|
|
|
function indexOfObject(array, property, element) {
|
|
for (var i = 0, length = array.length; i < length; ++i) {
|
|
if (array[i][property] === element) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// A sprintf implementation using %index (beginning at 1) to input
|
|
// arguments in the format string.
|
|
//
|
|
// Example:
|
|
//
|
|
// // Unexpected function in token
|
|
// sprintf('Unexpected %2 in %1.', 'token', 'function');
|
|
|
|
function sprintf(format) {
|
|
var args = slice.call(arguments, 1);
|
|
format = format.replace(/%(\d)/g, function (match, index) {
|
|
return '' + args[index - 1] || /* istanbul ignore next */ '';
|
|
});
|
|
return format;
|
|
}
|
|
|
|
// Polyfill for `Object.assign`.
|
|
|
|
var assign = /* istanbul ignore next */ function (dest) {
|
|
var args = slice.call(arguments, 1)
|
|
, src, prop;
|
|
|
|
for (var i = 0, length = args.length; i < length; ++i) {
|
|
src = args[i];
|
|
for (prop in src)
|
|
/* istanbul ignore else */
|
|
if (Object.prototype.hasOwnProperty.call(src, prop)) {
|
|
dest[prop] = src[prop];
|
|
}
|
|
}
|
|
|
|
return dest;
|
|
};
|
|
|
|
/* istanbul ignore else */
|
|
if (Object.assign)
|
|
assign = Object.assign;
|
|
|
|
// ### Error functions
|
|
|
|
exports.SyntaxError = SyntaxError;
|
|
|
|
// XXX: Eliminate this function and change the error type to be different from SyntaxError.
|
|
// This will unfortunately be a breaking change, because some downstream users depend
|
|
// on the error thrown being an instance of SyntaxError. For example, the Ace editor:
|
|
// <https://github.com/ajaxorg/ace/blob/4c7e5eb3f5d5ca9434847be51834a4e41661b852/lib/ace/mode/lua_worker.js#L55>
|
|
|
|
function fixupError(e) {
|
|
/* istanbul ignore if */
|
|
if (!Object.create)
|
|
return e;
|
|
return Object.create(e, {
|
|
'line': { 'writable': true, value: e.line },
|
|
'index': { 'writable': true, value: e.index },
|
|
'column': { 'writable': true, value: e.column }
|
|
});
|
|
}
|
|
|
|
// #### Raise an exception.
|
|
//
|
|
// Raise an exception by passing a token, a string format and its paramters.
|
|
//
|
|
// The passed tokens location will automatically be added to the error
|
|
// message if it exists, if not it will default to the lexers current
|
|
// position.
|
|
//
|
|
// Example:
|
|
//
|
|
// // [1:0] expected [ near (
|
|
// raise(token, "expected %1 near %2", '[', token.value);
|
|
|
|
function raise(token) {
|
|
var message = sprintf.apply(null, slice.call(arguments, 1))
|
|
, error, col;
|
|
|
|
if (token === null || typeof token.line === 'undefined') {
|
|
col = index - lineStart + 1;
|
|
error = fixupError(new SyntaxError(sprintf('[%1:%2] %3', line, col, message)));
|
|
error.index = index;
|
|
error.line = line;
|
|
error.column = col;
|
|
} else {
|
|
col = token.range[0] - token.lineStart;
|
|
error = fixupError(new SyntaxError(sprintf('[%1:%2] %3', token.line, col, message)));
|
|
error.line = token.line;
|
|
error.index = token.range[0];
|
|
error.column = col;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
function tokenValue(token) {
|
|
var raw = input.slice(token.range[0], token.range[1]);
|
|
if (raw)
|
|
return raw;
|
|
return token.value;
|
|
}
|
|
|
|
// #### Raise an unexpected token error.
|
|
//
|
|
// Example:
|
|
//
|
|
// // expected <name> near '0'
|
|
// raiseUnexpectedToken('<name>', token);
|
|
|
|
function raiseUnexpectedToken(type, token) {
|
|
raise(token, errors.expectedToken, type, tokenValue(token));
|
|
}
|
|
|
|
// #### Raise a general unexpected error
|
|
//
|
|
// Usage should pass either a token object or a symbol string which was
|
|
// expected. We can also specify a nearby token such as <eof>, this will
|
|
// default to the currently active token.
|
|
//
|
|
// Example:
|
|
//
|
|
// // Unexpected symbol 'end' near '<eof>'
|
|
// unexpected(token);
|
|
//
|
|
// If there's no token in the buffer it means we have reached <eof>.
|
|
|
|
function unexpected(found) {
|
|
var near = tokenValue(lookahead);
|
|
if ('undefined' !== typeof found.type) {
|
|
var type;
|
|
switch (found.type) {
|
|
case StringLiteral: type = 'string'; break;
|
|
case Keyword: type = 'keyword'; break;
|
|
case Identifier: type = 'identifier'; break;
|
|
case NumericLiteral: type = 'number'; break;
|
|
case Punctuator: type = 'symbol'; break;
|
|
case BooleanLiteral: type = 'boolean'; break;
|
|
case NilLiteral:
|
|
return raise(found, errors.unexpected, 'symbol', 'nil', near);
|
|
case EOF:
|
|
return raise(found, errors.unexpectedEOF);
|
|
}
|
|
return raise(found, errors.unexpected, type, tokenValue(found), near);
|
|
}
|
|
return raise(found, errors.unexpected, 'symbol', found, near);
|
|
}
|
|
|
|
// Lexer
|
|
// -----
|
|
//
|
|
// The lexer, or the tokenizer reads the input string character by character
|
|
// and derives a token left-right. To be as efficient as possible the lexer
|
|
// prioritizes the common cases such as identifiers. It also works with
|
|
// character codes instead of characters as string comparisons was the
|
|
// biggest bottleneck of the parser.
|
|
//
|
|
// If `options.comments` is enabled, all comments encountered will be stored
|
|
// in an array which later will be appended to the chunk object. If disabled,
|
|
// they will simply be disregarded.
|
|
//
|
|
// When the lexer has derived a valid token, it will be returned as an object
|
|
// containing its value and as well as its position in the input string (this
|
|
// is always enabled to provide proper debug messages).
|
|
//
|
|
// `lex()` starts lexing and returns the following token in the stream.
|
|
|
|
var index
|
|
, token
|
|
, previousToken
|
|
, lookahead
|
|
, comments
|
|
, tokenStart
|
|
, line
|
|
, lineStart;
|
|
|
|
exports.lex = lex;
|
|
|
|
function lex() {
|
|
skipWhiteSpace();
|
|
|
|
// Skip comments beginning with --
|
|
while (45 === input.charCodeAt(index) &&
|
|
45 === input.charCodeAt(index + 1)) {
|
|
scanComment();
|
|
skipWhiteSpace();
|
|
}
|
|
if (index >= length) return {
|
|
type : EOF
|
|
, value: '<eof>'
|
|
, line: line
|
|
, lineStart: lineStart
|
|
, range: [index, index]
|
|
};
|
|
|
|
var charCode = input.charCodeAt(index)
|
|
, next = input.charCodeAt(index + 1);
|
|
|
|
// Memorize the range index where the token begins.
|
|
tokenStart = index;
|
|
if (isIdentifierStart(charCode)) return scanIdentifierOrKeyword();
|
|
|
|
switch (charCode) {
|
|
case 39: case 34: // '"
|
|
return scanStringLiteral();
|
|
|
|
case 48: case 49: case 50: case 51: case 52: case 53:
|
|
case 54: case 55: case 56: case 57: // 0-9
|
|
return scanNumericLiteral();
|
|
|
|
case 46: // .
|
|
// If the dot is followed by a digit it's a float.
|
|
if (isDecDigit(next)) return scanNumericLiteral();
|
|
if (46 === next) {
|
|
if (46 === input.charCodeAt(index + 2)) return scanVarargLiteral();
|
|
return scanPunctuator('..');
|
|
}
|
|
return scanPunctuator('.');
|
|
|
|
case 61: // =
|
|
if (61 === next) return scanPunctuator('==');
|
|
return scanPunctuator('=');
|
|
|
|
case 62: // >
|
|
if (features.bitwiseOperators)
|
|
if (62 === next) return scanPunctuator('>>');
|
|
if (61 === next) return scanPunctuator('>=');
|
|
return scanPunctuator('>');
|
|
|
|
case 60: // <
|
|
if (features.bitwiseOperators)
|
|
if (60 === next) return scanPunctuator('<<');
|
|
if (61 === next) return scanPunctuator('<=');
|
|
return scanPunctuator('<');
|
|
|
|
case 126: // ~
|
|
if (61 === next) return scanPunctuator('~=');
|
|
if (!features.bitwiseOperators)
|
|
break;
|
|
return scanPunctuator('~');
|
|
|
|
case 58: // :
|
|
if (features.labels)
|
|
if (58 === next) return scanPunctuator('::');
|
|
return scanPunctuator(':');
|
|
|
|
case 91: // [
|
|
// Check for a multiline string, they begin with [= or [[
|
|
if (91 === next || 61 === next) return scanLongStringLiteral();
|
|
return scanPunctuator('[');
|
|
|
|
case 47: // /
|
|
// Check for integer division op (//)
|
|
if (features.integerDivision)
|
|
if (47 === next) return scanPunctuator('//');
|
|
return scanPunctuator('/');
|
|
|
|
case 38: case 124: // & |
|
|
if (!features.bitwiseOperators)
|
|
break;
|
|
|
|
/* fall through */
|
|
case 42: case 94: case 37: case 44: case 123: case 125:
|
|
case 93: case 40: case 41: case 59: case 35: case 45:
|
|
case 43: // * ^ % , { } ] ( ) ; # - +
|
|
return scanPunctuator(input.charAt(index));
|
|
}
|
|
|
|
return unexpected(input.charAt(index));
|
|
}
|
|
|
|
// Whitespace has no semantic meaning in lua so simply skip ahead while
|
|
// tracking the encounted newlines. Any kind of eol sequence is counted as a
|
|
// single line.
|
|
|
|
function consumeEOL() {
|
|
var charCode = input.charCodeAt(index)
|
|
, peekCharCode = input.charCodeAt(index + 1);
|
|
|
|
if (isLineTerminator(charCode)) {
|
|
// Count \n\r and \r\n as one newline.
|
|
if (10 === charCode && 13 === peekCharCode) ++index;
|
|
if (13 === charCode && 10 === peekCharCode) ++index;
|
|
++line;
|
|
lineStart = ++index;
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function skipWhiteSpace() {
|
|
while (index < length) {
|
|
var charCode = input.charCodeAt(index);
|
|
if (isWhiteSpace(charCode)) {
|
|
++index;
|
|
} else if (!consumeEOL()) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Identifiers, keywords, booleans and nil all look the same syntax wise. We
|
|
// simply go through them one by one and defaulting to an identifier if no
|
|
// previous case matched.
|
|
|
|
function scanIdentifierOrKeyword() {
|
|
var value, type;
|
|
|
|
// Slicing the input string is prefered before string concatenation in a
|
|
// loop for performance reasons.
|
|
while (isIdentifierPart(input.charCodeAt(++index)));
|
|
value = encodingMode.fixup(input.slice(tokenStart, index));
|
|
|
|
// Decide on the token type and possibly cast the value.
|
|
if (isKeyword(value)) {
|
|
type = Keyword;
|
|
} else if ('true' === value || 'false' === value) {
|
|
type = BooleanLiteral;
|
|
value = ('true' === value);
|
|
} else if ('nil' === value) {
|
|
type = NilLiteral;
|
|
value = null;
|
|
} else {
|
|
type = Identifier;
|
|
}
|
|
|
|
return {
|
|
type: type
|
|
, value: value
|
|
, line: line
|
|
, lineStart: lineStart
|
|
, range: [tokenStart, index]
|
|
};
|
|
}
|
|
|
|
// Once a punctuator reaches this function it should already have been
|
|
// validated so we simply return it as a token.
|
|
|
|
function scanPunctuator(value) {
|
|
index += value.length;
|
|
return {
|
|
type: Punctuator
|
|
, value: value
|
|
, line: line
|
|
, lineStart: lineStart
|
|
, range: [tokenStart, index]
|
|
};
|
|
}
|
|
|
|
// A vararg literal consists of three dots.
|
|
|
|
function scanVarargLiteral() {
|
|
index += 3;
|
|
return {
|
|
type: VarargLiteral
|
|
, value: '...'
|
|
, line: line
|
|
, lineStart: lineStart
|
|
, range: [tokenStart, index]
|
|
};
|
|
}
|
|
|
|
// Find the string literal by matching the delimiter marks used.
|
|
|
|
function scanStringLiteral() {
|
|
var delimiter = input.charCodeAt(index++)
|
|
, beginLine = line
|
|
, beginLineStart = lineStart
|
|
, stringStart = index
|
|
, string = encodingMode.discardStrings ? null : ''
|
|
, charCode;
|
|
|
|
for (;;) {
|
|
charCode = input.charCodeAt(index++);
|
|
if (delimiter === charCode) break;
|
|
// EOF or `\n` terminates a string literal. If we haven't found the
|
|
// ending delimiter by now, raise an exception.
|
|
if (index > length || isLineTerminator(charCode)) {
|
|
string += input.slice(stringStart, index - 1);
|
|
raise(null, errors.unfinishedString, input.slice(tokenStart, index - 1));
|
|
}
|
|
if (92 === charCode) { // backslash
|
|
if (!encodingMode.discardStrings) {
|
|
var beforeEscape = input.slice(stringStart, index - 1);
|
|
string += encodingMode.fixup(beforeEscape);
|
|
}
|
|
var escapeValue = readEscapeSequence();
|
|
if (!encodingMode.discardStrings)
|
|
string += escapeValue;
|
|
stringStart = index;
|
|
}
|
|
}
|
|
if (!encodingMode.discardStrings) {
|
|
string += encodingMode.encodeByte(null);
|
|
string += encodingMode.fixup(input.slice(stringStart, index - 1));
|
|
}
|
|
|
|
return {
|
|
type: StringLiteral
|
|
, value: string
|
|
, line: beginLine
|
|
, lineStart: beginLineStart
|
|
, lastLine: line
|
|
, lastLineStart: lineStart
|
|
, range: [tokenStart, index]
|
|
};
|
|
}
|
|
|
|
// Expect a multiline string literal and return it as a regular string
|
|
// literal, if it doesn't validate into a valid multiline string, throw an
|
|
// exception.
|
|
|
|
function scanLongStringLiteral() {
|
|
var beginLine = line
|
|
, beginLineStart = lineStart
|
|
, string = readLongString(false);
|
|
// Fail if it's not a multiline literal.
|
|
if (false === string) raise(token, errors.expected, '[', tokenValue(token));
|
|
|
|
return {
|
|
type: StringLiteral
|
|
, value: encodingMode.discardStrings ? null : encodingMode.fixup(string)
|
|
, line: beginLine
|
|
, lineStart: beginLineStart
|
|
, lastLine: line
|
|
, lastLineStart: lineStart
|
|
, range: [tokenStart, index]
|
|
};
|
|
}
|
|
|
|
// Numeric literals will be returned as floating-point numbers instead of
|
|
// strings. The raw value should be retrieved from slicing the input string
|
|
// later on in the process.
|
|
//
|
|
// If a hexadecimal number is encountered, it will be converted.
|
|
|
|
function scanNumericLiteral() {
|
|
var character = input.charAt(index)
|
|
, next = input.charAt(index + 1);
|
|
|
|
var literal = ('0' === character && 'xX'.indexOf(next || null) >= 0) ?
|
|
readHexLiteral() : readDecLiteral();
|
|
|
|
var foundImaginaryUnit = readImaginaryUnitSuffix()
|
|
, foundInt64Suffix = readInt64Suffix();
|
|
|
|
if (foundInt64Suffix && (foundImaginaryUnit || literal.hasFractionPart)) {
|
|
raise(null, errors.malformedNumber, input.slice(tokenStart, index));
|
|
}
|
|
|
|
return {
|
|
type: NumericLiteral
|
|
, value: literal.value
|
|
, line: line
|
|
, lineStart: lineStart
|
|
, range: [tokenStart, index]
|
|
};
|
|
}
|
|
|
|
function readImaginaryUnitSuffix() {
|
|
if (!features.imaginaryNumbers) return;
|
|
|
|
// Imaginary unit number suffix is optional.
|
|
// See http://luajit.org/ext_ffi_api.html#literals
|
|
if ('iI'.indexOf(input.charAt(index) || null) >= 0) {
|
|
++index;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function readInt64Suffix() {
|
|
if (!features.integerSuffixes) return;
|
|
|
|
// Int64/uint64 number suffix is optional.
|
|
// See http://luajit.org/ext_ffi_api.html#literals
|
|
|
|
if ('uU'.indexOf(input.charAt(index) || null) >= 0) {
|
|
++index;
|
|
if ('lL'.indexOf(input.charAt(index) || null) >= 0) {
|
|
++index;
|
|
if ('lL'.indexOf(input.charAt(index) || null) >= 0) {
|
|
++index;
|
|
return 'ULL';
|
|
} else {
|
|
// UL but no L
|
|
raise(null, errors.malformedNumber, input.slice(tokenStart, index));
|
|
}
|
|
} else {
|
|
// U but no L
|
|
raise(null, errors.malformedNumber, input.slice(tokenStart, index));
|
|
}
|
|
} else if ('lL'.indexOf(input.charAt(index) || null) >= 0) {
|
|
++index;
|
|
if ('lL'.indexOf(input.charAt(index) || null) >= 0) {
|
|
++index;
|
|
return 'LL';
|
|
} else {
|
|
// First L but no second L
|
|
raise(null, errors.malformedNumber, input.slice(tokenStart, index));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Lua hexadecimals have an optional fraction part and an optional binary
|
|
// exoponent part. These are not included in JavaScript so we will compute
|
|
// all three parts separately and then sum them up at the end of the function
|
|
// with the following algorithm.
|
|
//
|
|
// Digit := toDec(digit)
|
|
// Fraction := toDec(fraction) / 16 ^ fractionCount
|
|
// BinaryExp := 2 ^ binaryExp
|
|
// Number := ( Digit + Fraction ) * BinaryExp
|
|
|
|
function readHexLiteral() {
|
|
var fraction = 0 // defaults to 0 as it gets summed
|
|
, binaryExponent = 1 // defaults to 1 as it gets multiplied
|
|
, binarySign = 1 // positive
|
|
, digit, fractionStart, exponentStart, digitStart;
|
|
|
|
digitStart = index += 2; // Skip 0x part
|
|
|
|
// A minimum of one hex digit is required.
|
|
if (!isHexDigit(input.charCodeAt(index)))
|
|
raise(null, errors.malformedNumber, input.slice(tokenStart, index));
|
|
|
|
while (isHexDigit(input.charCodeAt(index))) ++index;
|
|
// Convert the hexadecimal digit to base 10.
|
|
digit = parseInt(input.slice(digitStart, index), 16);
|
|
|
|
// Fraction part is optional.
|
|
var foundFraction = false;
|
|
if ('.' === input.charAt(index)) {
|
|
foundFraction = true;
|
|
fractionStart = ++index;
|
|
|
|
while (isHexDigit(input.charCodeAt(index))) ++index;
|
|
fraction = input.slice(fractionStart, index);
|
|
|
|
// Empty fraction parts should default to 0, others should be converted
|
|
// 0.x form so we can use summation at the end.
|
|
fraction = (fractionStart === index) ? 0
|
|
: parseInt(fraction, 16) / Math.pow(16, index - fractionStart);
|
|
}
|
|
|
|
// Binary exponents are optional
|
|
var foundBinaryExponent = false;
|
|
if ('pP'.indexOf(input.charAt(index) || null) >= 0) {
|
|
foundBinaryExponent = true;
|
|
++index;
|
|
|
|
// Sign part is optional and defaults to 1 (positive).
|
|
if ('+-'.indexOf(input.charAt(index) || null) >= 0)
|
|
binarySign = ('+' === input.charAt(index++)) ? 1 : -1;
|
|
|
|
exponentStart = index;
|
|
|
|
// The binary exponent sign requires a decimal digit.
|
|
if (!isDecDigit(input.charCodeAt(index)))
|
|
raise(null, errors.malformedNumber, input.slice(tokenStart, index));
|
|
|
|
while (isDecDigit(input.charCodeAt(index))) ++index;
|
|
binaryExponent = input.slice(exponentStart, index);
|
|
|
|
// Calculate the binary exponent of the number.
|
|
binaryExponent = Math.pow(2, binaryExponent * binarySign);
|
|
}
|
|
|
|
return {
|
|
value: (digit + fraction) * binaryExponent,
|
|
hasFractionPart: foundFraction || foundBinaryExponent
|
|
};
|
|
}
|
|
|
|
// Decimal numbers are exactly the same in Lua and in JavaScript, because of
|
|
// this we check where the token ends and then parse it with native
|
|
// functions.
|
|
|
|
function readDecLiteral() {
|
|
while (isDecDigit(input.charCodeAt(index))) ++index;
|
|
// Fraction part is optional
|
|
var foundFraction = false;
|
|
if ('.' === input.charAt(index)) {
|
|
foundFraction = true;
|
|
++index;
|
|
// Fraction part defaults to 0
|
|
while (isDecDigit(input.charCodeAt(index))) ++index;
|
|
}
|
|
|
|
// Exponent part is optional.
|
|
var foundExponent = false;
|
|
if ('eE'.indexOf(input.charAt(index) || null) >= 0) {
|
|
foundExponent = true;
|
|
++index;
|
|
// Sign part is optional.
|
|
if ('+-'.indexOf(input.charAt(index) || null) >= 0) ++index;
|
|
// An exponent is required to contain at least one decimal digit.
|
|
if (!isDecDigit(input.charCodeAt(index)))
|
|
raise(null, errors.malformedNumber, input.slice(tokenStart, index));
|
|
|
|
while (isDecDigit(input.charCodeAt(index))) ++index;
|
|
}
|
|
|
|
return {
|
|
value: parseFloat(input.slice(tokenStart, index)),
|
|
hasFractionPart: foundFraction || foundExponent
|
|
};
|
|
}
|
|
|
|
function readUnicodeEscapeSequence() {
|
|
var sequenceStart = index++;
|
|
|
|
if (input.charAt(index++) !== '{')
|
|
raise(null, errors.braceExpected, '{', '\\' + input.slice(sequenceStart, index));
|
|
if (!isHexDigit(input.charCodeAt(index)))
|
|
raise(null, errors.hexadecimalDigitExpected, '\\' + input.slice(sequenceStart, index));
|
|
|
|
while (input.charCodeAt(index) === 0x30) ++index;
|
|
var escStart = index;
|
|
|
|
while (isHexDigit(input.charCodeAt(index))) {
|
|
++index;
|
|
if (index - escStart > 6)
|
|
raise(null, errors.tooLargeCodepoint, '\\' + input.slice(sequenceStart, index));
|
|
}
|
|
|
|
var b = input.charAt(index++);
|
|
if (b !== '}') {
|
|
if ((b === '"') || (b === "'"))
|
|
raise(null, errors.braceExpected, '}', '\\' + input.slice(sequenceStart, index--));
|
|
else
|
|
raise(null, errors.hexadecimalDigitExpected, '\\' + input.slice(sequenceStart, index));
|
|
}
|
|
|
|
var codepoint = parseInt(input.slice(escStart, index - 1) || '0', 16);
|
|
var frag = '\\' + input.slice(sequenceStart, index);
|
|
|
|
if (codepoint > 0x10ffff) {
|
|
raise(null, errors.tooLargeCodepoint, frag);
|
|
}
|
|
|
|
return encodingMode.encodeUTF8(codepoint, frag);
|
|
}
|
|
|
|
// Translate escape sequences to the actual characters.
|
|
function readEscapeSequence() {
|
|
var sequenceStart = index;
|
|
switch (input.charAt(index)) {
|
|
// Lua allow the following escape sequences.
|
|
case 'a': ++index; return '\x07';
|
|
case 'n': ++index; return '\n';
|
|
case 'r': ++index; return '\r';
|
|
case 't': ++index; return '\t';
|
|
case 'v': ++index; return '\x0b';
|
|
case 'b': ++index; return '\b';
|
|
case 'f': ++index; return '\f';
|
|
|
|
// Backslash at the end of the line. We treat all line endings as equivalent,
|
|
// and as representing the [LF] character (code 10). Lua 5.1 through 5.3
|
|
// have been verified to behave the same way.
|
|
case '\r':
|
|
case '\n':
|
|
consumeEOL();
|
|
return '\n';
|
|
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
case '5': case '6': case '7': case '8': case '9':
|
|
// \ddd, where ddd is a sequence of up to three decimal digits.
|
|
while (isDecDigit(input.charCodeAt(index)) && index - sequenceStart < 3) ++index;
|
|
|
|
var frag = input.slice(sequenceStart, index);
|
|
var ddd = parseInt(frag, 10);
|
|
if (ddd > 255) {
|
|
raise(null, errors.decimalEscapeTooLarge, '\\' + ddd);
|
|
}
|
|
return encodingMode.encodeByte(ddd, '\\' + frag);
|
|
|
|
case 'z':
|
|
if (features.skipWhitespaceEscape) {
|
|
++index;
|
|
skipWhiteSpace();
|
|
return '';
|
|
}
|
|
break;
|
|
|
|
case 'x':
|
|
if (features.hexEscapes) {
|
|
// \xXX, where XX is a sequence of exactly two hexadecimal digits
|
|
if (isHexDigit(input.charCodeAt(index + 1)) &&
|
|
isHexDigit(input.charCodeAt(index + 2))) {
|
|
index += 3;
|
|
return encodingMode.encodeByte(parseInt(input.slice(sequenceStart + 1, index), 16), '\\' + input.slice(sequenceStart, index));
|
|
}
|
|
raise(null, errors.hexadecimalDigitExpected, '\\' + input.slice(sequenceStart, index + 2));
|
|
}
|
|
break;
|
|
|
|
case 'u':
|
|
if (features.unicodeEscapes)
|
|
return readUnicodeEscapeSequence();
|
|
break;
|
|
|
|
case '\\': case '"': case "'":
|
|
return input.charAt(index++);
|
|
}
|
|
|
|
if (features.strictEscapes)
|
|
raise(null, errors.invalidEscape, '\\' + input.slice(sequenceStart, index + 1));
|
|
return input.charAt(index++);
|
|
}
|
|
|
|
// Comments begin with -- after which it will be decided if they are
|
|
// multiline comments or not.
|
|
//
|
|
// The multiline functionality works the exact same way as with string
|
|
// literals so we reuse the functionality.
|
|
|
|
function scanComment() {
|
|
tokenStart = index;
|
|
index += 2; // --
|
|
|
|
var character = input.charAt(index)
|
|
, content = ''
|
|
, isLong = false
|
|
, commentStart = index
|
|
, lineStartComment = lineStart
|
|
, lineComment = line;
|
|
|
|
if ('[' === character) {
|
|
content = readLongString(true);
|
|
// This wasn't a multiline comment after all.
|
|
if (false === content) content = character;
|
|
else isLong = true;
|
|
}
|
|
// Scan until next line as long as it's not a multiline comment.
|
|
if (!isLong) {
|
|
while (index < length) {
|
|
if (isLineTerminator(input.charCodeAt(index))) break;
|
|
++index;
|
|
}
|
|
if (options.comments) content = input.slice(commentStart, index);
|
|
}
|
|
|
|
if (options.comments) {
|
|
var node = ast.comment(content, input.slice(tokenStart, index));
|
|
|
|
// `Marker`s depend on tokens available in the parser and as comments are
|
|
// intercepted in the lexer all location data is set manually.
|
|
if (options.locations) {
|
|
node.loc = {
|
|
start: { line: lineComment, column: tokenStart - lineStartComment }
|
|
, end: { line: line, column: index - lineStart }
|
|
};
|
|
}
|
|
if (options.ranges) {
|
|
node.range = [tokenStart, index];
|
|
}
|
|
if (options.onCreateNode) options.onCreateNode(node);
|
|
comments.push(node);
|
|
}
|
|
}
|
|
|
|
// Read a multiline string by calculating the depth of `=` characters and
|
|
// then appending until an equal depth is found.
|
|
|
|
function readLongString(isComment) {
|
|
var level = 0
|
|
, content = ''
|
|
, terminator = false
|
|
, character, stringStart, firstLine = line;
|
|
|
|
++index; // [
|
|
|
|
// Calculate the depth of the comment.
|
|
while ('=' === input.charAt(index + level)) ++level;
|
|
// Exit, this is not a long string afterall.
|
|
if ('[' !== input.charAt(index + level)) return false;
|
|
|
|
index += level + 1;
|
|
|
|
// If the first character is a newline, ignore it and begin on next line.
|
|
if (isLineTerminator(input.charCodeAt(index))) consumeEOL();
|
|
|
|
stringStart = index;
|
|
while (index < length) {
|
|
// To keep track of line numbers run the `consumeEOL()` which increments
|
|
// its counter.
|
|
while (isLineTerminator(input.charCodeAt(index))) consumeEOL();
|
|
|
|
character = input.charAt(index++);
|
|
|
|
// Once the delimiter is found, iterate through the depth count and see
|
|
// if it matches.
|
|
if (']' === character) {
|
|
terminator = true;
|
|
for (var i = 0; i < level; ++i) {
|
|
if ('=' !== input.charAt(index + i)) terminator = false;
|
|
}
|
|
if (']' !== input.charAt(index + level)) terminator = false;
|
|
}
|
|
|
|
// We reached the end of the multiline string. Get out now.
|
|
if (terminator) {
|
|
content += input.slice(stringStart, index - 1);
|
|
index += level + 1;
|
|
return content;
|
|
}
|
|
}
|
|
|
|
raise(null, isComment ?
|
|
errors.unfinishedLongComment :
|
|
errors.unfinishedLongString,
|
|
firstLine, '<eof>');
|
|
}
|
|
|
|
// ## Lex functions and helpers.
|
|
|
|
// Read the next token.
|
|
//
|
|
// This is actually done by setting the current token to the lookahead and
|
|
// reading in the new lookahead token.
|
|
|
|
function next() {
|
|
previousToken = token;
|
|
token = lookahead;
|
|
lookahead = lex();
|
|
}
|
|
|
|
// Consume a token if its value matches. Once consumed or not, return the
|
|
// success of the operation.
|
|
|
|
function consume(value) {
|
|
if (value === token.value) {
|
|
next();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Expect the next token value to match. If not, throw an exception.
|
|
|
|
function expect(value) {
|
|
if (value === token.value) next();
|
|
else raise(token, errors.expected, value, tokenValue(token));
|
|
}
|
|
|
|
// ### Validation functions
|
|
|
|
function isWhiteSpace(charCode) {
|
|
return 9 === charCode || 32 === charCode || 0xB === charCode || 0xC === charCode;
|
|
}
|
|
|
|
function isLineTerminator(charCode) {
|
|
return 10 === charCode || 13 === charCode;
|
|
}
|
|
|
|
function isDecDigit(charCode) {
|
|
return charCode >= 48 && charCode <= 57;
|
|
}
|
|
|
|
function isHexDigit(charCode) {
|
|
return (charCode >= 48 && charCode <= 57) || (charCode >= 97 && charCode <= 102) || (charCode >= 65 && charCode <= 70);
|
|
}
|
|
|
|
// From [Lua 5.2](http://www.lua.org/manual/5.2/manual.html#8.1) onwards
|
|
// identifiers cannot use 'locale-dependent' letters (i.e. dependent on the C locale).
|
|
// On the other hand, LuaJIT allows arbitrary octets ≥ 128 in identifiers.
|
|
|
|
function isIdentifierStart(charCode) {
|
|
if ((charCode >= 65 && charCode <= 90) || (charCode >= 97 && charCode <= 122) || 95 === charCode)
|
|
return true;
|
|
if (features.extendedIdentifiers && charCode >= 128)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
function isIdentifierPart(charCode) {
|
|
if ((charCode >= 65 && charCode <= 90) || (charCode >= 97 && charCode <= 122) || 95 === charCode || (charCode >= 48 && charCode <= 57))
|
|
return true;
|
|
if (features.extendedIdentifiers && charCode >= 128)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// [3.1 Lexical Conventions](http://www.lua.org/manual/5.2/manual.html#3.1)
|
|
//
|
|
// `true`, `false` and `nil` will not be considered keywords, but literals.
|
|
|
|
function isKeyword(id) {
|
|
switch (id.length) {
|
|
case 2:
|
|
return 'do' === id || 'if' === id || 'in' === id || 'or' === id;
|
|
case 3:
|
|
return 'and' === id || 'end' === id || 'for' === id || 'not' === id;
|
|
case 4:
|
|
if ('else' === id || 'then' === id)
|
|
return true;
|
|
if (features.labels && !features.contextualGoto)
|
|
return ('goto' === id);
|
|
return false;
|
|
case 5:
|
|
return 'break' === id || 'local' === id || 'until' === id || 'while' === id;
|
|
case 6:
|
|
return 'elseif' === id || 'repeat' === id || 'return' === id;
|
|
case 8:
|
|
return 'function' === id;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function isUnary(token) {
|
|
if (Punctuator === token.type) return '#-~'.indexOf(token.value) >= 0;
|
|
if (Keyword === token.type) return 'not' === token.value;
|
|
return false;
|
|
}
|
|
|
|
// Check if the token syntactically closes a block.
|
|
|
|
function isBlockFollow(token) {
|
|
if (EOF === token.type) return true;
|
|
if (Keyword !== token.type) return false;
|
|
switch (token.value) {
|
|
case 'else': case 'elseif':
|
|
case 'end': case 'until':
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Scope
|
|
// -----
|
|
|
|
// Store each block scope as a an array of identifier names. Each scope is
|
|
// stored in an FILO-array.
|
|
var scopes
|
|
// The current scope index
|
|
, scopeDepth
|
|
// A list of all global identifier nodes.
|
|
, globals;
|
|
|
|
// Create a new scope inheriting all declarations from the previous scope.
|
|
function createScope() {
|
|
var scope = scopes[scopeDepth++].slice();
|
|
scopes.push(scope);
|
|
if (options.onCreateScope) options.onCreateScope();
|
|
}
|
|
|
|
// Exit and remove the current scope.
|
|
function destroyScope() {
|
|
var scope = scopes.pop();
|
|
--scopeDepth;
|
|
if (options.onDestroyScope) options.onDestroyScope();
|
|
}
|
|
|
|
// Add identifier name to the current scope if it doesnt already exist.
|
|
function scopeIdentifierName(name) {
|
|
if (options.onLocalDeclaration) options.onLocalDeclaration(name);
|
|
if (-1 !== indexOf(scopes[scopeDepth], name)) return;
|
|
scopes[scopeDepth].push(name);
|
|
}
|
|
|
|
// Add identifier to the current scope
|
|
function scopeIdentifier(node) {
|
|
scopeIdentifierName(node.name);
|
|
attachScope(node, true);
|
|
}
|
|
|
|
// Attach scope information to node. If the node is global, store it in the
|
|
// globals array so we can return the information to the user.
|
|
function attachScope(node, isLocal) {
|
|
if (!isLocal && -1 === indexOfObject(globals, 'name', node.name))
|
|
globals.push(node);
|
|
|
|
node.isLocal = isLocal;
|
|
}
|
|
|
|
// Is the identifier name available in this scope.
|
|
function scopeHasName(name) {
|
|
return (-1 !== indexOf(scopes[scopeDepth], name));
|
|
}
|
|
|
|
// Location tracking
|
|
// -----------------
|
|
//
|
|
// Locations are stored in FILO-array as a `Marker` object consisting of both
|
|
// `loc` and `range` data. Once a `Marker` is popped off the list an end
|
|
// location is added and the data is attached to a syntax node.
|
|
|
|
var locations = []
|
|
, trackLocations;
|
|
|
|
function createLocationMarker() {
|
|
return new Marker(token);
|
|
}
|
|
|
|
function Marker(token) {
|
|
if (options.locations) {
|
|
this.loc = {
|
|
start: {
|
|
line: token.line
|
|
, column: token.range[0] - token.lineStart
|
|
}
|
|
, end: {
|
|
line: 0
|
|
, column: 0
|
|
}
|
|
};
|
|
}
|
|
if (options.ranges) this.range = [token.range[0], 0];
|
|
}
|
|
|
|
// Complete the location data stored in the `Marker` by adding the location
|
|
// of the *previous token* as an end location.
|
|
Marker.prototype.complete = function() {
|
|
if (options.locations) {
|
|
this.loc.end.line = previousToken.lastLine || previousToken.line;
|
|
this.loc.end.column = previousToken.range[1] - (previousToken.lastLineStart || previousToken.lineStart);
|
|
}
|
|
if (options.ranges) {
|
|
this.range[1] = previousToken.range[1];
|
|
}
|
|
};
|
|
|
|
Marker.prototype.bless = function (node) {
|
|
if (this.loc) {
|
|
var loc = this.loc;
|
|
node.loc = {
|
|
start: {
|
|
line: loc.start.line,
|
|
column: loc.start.column
|
|
},
|
|
end: {
|
|
line: loc.end.line,
|
|
column: loc.end.column
|
|
}
|
|
};
|
|
}
|
|
if (this.range) {
|
|
node.range = [
|
|
this.range[0],
|
|
this.range[1]
|
|
];
|
|
}
|
|
};
|
|
|
|
// Create a new `Marker` and add it to the FILO-array.
|
|
function markLocation() {
|
|
if (trackLocations) locations.push(createLocationMarker());
|
|
}
|
|
|
|
// Push an arbitrary `Marker` object onto the FILO-array.
|
|
function pushLocation(marker) {
|
|
if (trackLocations) locations.push(marker);
|
|
}
|
|
|
|
// Control flow tracking
|
|
// ---------------------
|
|
// A context object that validates loop breaks and `goto`-based control flow.
|
|
|
|
function FullFlowContext() {
|
|
this.scopes = [];
|
|
this.pendingGotos = [];
|
|
}
|
|
|
|
FullFlowContext.prototype.isInLoop = function () {
|
|
var i = this.scopes.length;
|
|
while (i --> 0) {
|
|
if (this.scopes[i].isLoop)
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
FullFlowContext.prototype.pushScope = function (isLoop) {
|
|
var scope = {
|
|
labels: {},
|
|
locals: [],
|
|
deferredGotos: [],
|
|
isLoop: !!isLoop
|
|
};
|
|
this.scopes.push(scope);
|
|
};
|
|
|
|
FullFlowContext.prototype.popScope = function () {
|
|
for (var i = 0; i < this.pendingGotos.length; ++i) {
|
|
var theGoto = this.pendingGotos[i];
|
|
if (theGoto.maxDepth >= this.scopes.length)
|
|
if (--theGoto.maxDepth <= 0)
|
|
raise(theGoto.token, errors.labelNotVisible, theGoto.target);
|
|
}
|
|
|
|
this.scopes.pop();
|
|
};
|
|
|
|
FullFlowContext.prototype.addGoto = function (target, token) {
|
|
var localCounts = [];
|
|
|
|
for (var i = 0; i < this.scopes.length; ++i) {
|
|
var scope = this.scopes[i];
|
|
localCounts.push(scope.locals.length);
|
|
if (Object.prototype.hasOwnProperty.call(scope.labels, target))
|
|
return;
|
|
}
|
|
|
|
this.pendingGotos.push({
|
|
maxDepth: this.scopes.length,
|
|
target: target,
|
|
token: token,
|
|
localCounts: localCounts
|
|
});
|
|
};
|
|
|
|
FullFlowContext.prototype.addLabel = function (name, token) {
|
|
var scope = this.currentScope();
|
|
|
|
if (Object.prototype.hasOwnProperty.call(scope.labels, name)) {
|
|
raise(token, errors.labelAlreadyDefined, name, scope.labels[name].line);
|
|
} else {
|
|
var newGotos = [];
|
|
|
|
for (var i = 0; i < this.pendingGotos.length; ++i) {
|
|
var theGoto = this.pendingGotos[i];
|
|
|
|
if (theGoto.maxDepth >= this.scopes.length && theGoto.target === name) {
|
|
if (theGoto.localCounts[this.scopes.length - 1] < scope.locals.length) {
|
|
scope.deferredGotos.push(theGoto);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
newGotos.push(theGoto);
|
|
}
|
|
|
|
this.pendingGotos = newGotos;
|
|
}
|
|
|
|
scope.labels[name] = {
|
|
localCount: scope.locals.length,
|
|
line: token.line
|
|
};
|
|
};
|
|
|
|
FullFlowContext.prototype.addLocal = function (name, token) {
|
|
this.currentScope().locals.push({
|
|
name: name,
|
|
token: token
|
|
});
|
|
};
|
|
|
|
FullFlowContext.prototype.currentScope = function () {
|
|
return this.scopes[this.scopes.length - 1];
|
|
};
|
|
|
|
FullFlowContext.prototype.raiseDeferredErrors = function () {
|
|
var scope = this.currentScope();
|
|
var bads = scope.deferredGotos;
|
|
for (var i = 0; i < bads.length; ++i) {
|
|
var theGoto = bads[i];
|
|
raise(theGoto.token, errors.gotoJumpInLocalScope, theGoto.target, scope.locals[theGoto.localCounts[this.scopes.length - 1]].name);
|
|
}
|
|
// Would be dead code currently, but may be useful later
|
|
// if (bads.length)
|
|
// scope.deferredGotos = [];
|
|
};
|
|
|
|
// Simplified context that only checks the validity of loop breaks.
|
|
|
|
function LoopFlowContext() {
|
|
this.level = 0;
|
|
this.loopLevels = [];
|
|
}
|
|
|
|
LoopFlowContext.prototype.isInLoop = function () {
|
|
return !!this.loopLevels.length;
|
|
};
|
|
|
|
LoopFlowContext.prototype.pushScope = function (isLoop) {
|
|
++this.level;
|
|
if (isLoop)
|
|
this.loopLevels.push(this.level);
|
|
};
|
|
|
|
LoopFlowContext.prototype.popScope = function () {
|
|
var levels = this.loopLevels;
|
|
var levlen = levels.length;
|
|
if (levlen) {
|
|
if (levels[levlen - 1] === this.level)
|
|
levels.pop();
|
|
}
|
|
--this.level;
|
|
};
|
|
|
|
LoopFlowContext.prototype.addGoto =
|
|
LoopFlowContext.prototype.addLabel =
|
|
/* istanbul ignore next */
|
|
function () { throw new Error('This should never happen'); };
|
|
|
|
LoopFlowContext.prototype.addLocal =
|
|
LoopFlowContext.prototype.raiseDeferredErrors =
|
|
function () {};
|
|
|
|
function makeFlowContext() {
|
|
return features.labels ? new FullFlowContext() : new LoopFlowContext();
|
|
}
|
|
|
|
// Parse functions
|
|
// ---------------
|
|
|
|
// Chunk is the main program object. Syntactically it's the same as a block.
|
|
//
|
|
// chunk ::= block
|
|
|
|
function parseChunk() {
|
|
next();
|
|
markLocation();
|
|
if (options.scope) createScope();
|
|
var flowContext = makeFlowContext();
|
|
flowContext.allowVararg = true;
|
|
flowContext.pushScope();
|
|
var body = parseBlock(flowContext);
|
|
flowContext.popScope();
|
|
if (options.scope) destroyScope();
|
|
if (EOF !== token.type) unexpected(token);
|
|
// If the body is empty no previousToken exists when finishNode runs.
|
|
if (trackLocations && !body.length) previousToken = token;
|
|
return finishNode(ast.chunk(body));
|
|
}
|
|
|
|
// A block contains a list of statements with an optional return statement
|
|
// as its last statement.
|
|
//
|
|
// block ::= {stat} [retstat]
|
|
|
|
function parseBlock(flowContext) {
|
|
var block = []
|
|
, statement;
|
|
|
|
while (!isBlockFollow(token)) {
|
|
// Return has to be the last statement in a block.
|
|
// Likewise 'break' in Lua older than 5.2
|
|
if ('return' === token.value || (!features.relaxedBreak && 'break' === token.value)) {
|
|
block.push(parseStatement(flowContext));
|
|
break;
|
|
}
|
|
statement = parseStatement(flowContext);
|
|
consume(';');
|
|
// Statements are only added if they are returned, this allows us to
|
|
// ignore some statements, such as EmptyStatement.
|
|
if (statement) block.push(statement);
|
|
}
|
|
|
|
// Doesn't really need an ast node
|
|
return block;
|
|
}
|
|
|
|
// There are two types of statements, simple and compound.
|
|
//
|
|
// statement ::= break | goto | do | while | repeat | return
|
|
// | if | for | function | local | label | assignment
|
|
// | functioncall | ';'
|
|
|
|
function parseStatement(flowContext) {
|
|
markLocation();
|
|
|
|
if (Punctuator === token.type) {
|
|
if (consume('::')) return parseLabelStatement(flowContext);
|
|
}
|
|
|
|
// When a `;` is encounted, simply eat it without storing it.
|
|
if (features.emptyStatement) {
|
|
if (consume(';')) {
|
|
if (trackLocations) locations.pop();
|
|
return;
|
|
}
|
|
}
|
|
|
|
flowContext.raiseDeferredErrors();
|
|
|
|
if (Keyword === token.type) {
|
|
switch (token.value) {
|
|
case 'local': next(); return parseLocalStatement(flowContext);
|
|
case 'if': next(); return parseIfStatement(flowContext);
|
|
case 'return': next(); return parseReturnStatement(flowContext);
|
|
case 'function': next();
|
|
var name = parseFunctionName();
|
|
return parseFunctionDeclaration(name);
|
|
case 'while': next(); return parseWhileStatement(flowContext);
|
|
case 'for': next(); return parseForStatement(flowContext);
|
|
case 'repeat': next(); return parseRepeatStatement(flowContext);
|
|
case 'break': next();
|
|
if (!flowContext.isInLoop())
|
|
raise(token, errors.noLoopToBreak, token.value);
|
|
return parseBreakStatement();
|
|
case 'do': next(); return parseDoStatement(flowContext);
|
|
case 'goto': next(); return parseGotoStatement(flowContext);
|
|
}
|
|
}
|
|
|
|
if (features.contextualGoto &&
|
|
token.type === Identifier && token.value === 'goto' &&
|
|
lookahead.type === Identifier && lookahead.value !== 'goto') {
|
|
next(); return parseGotoStatement(flowContext);
|
|
}
|
|
|
|
// Assignments memorizes the location and pushes it manually for wrapper nodes.
|
|
if (trackLocations) locations.pop();
|
|
|
|
return parseAssignmentOrCallStatement(flowContext);
|
|
}
|
|
|
|
// ## Statements
|
|
|
|
// label ::= '::' Name '::'
|
|
|
|
function parseLabelStatement(flowContext) {
|
|
var nameToken = token
|
|
, label = parseIdentifier();
|
|
|
|
if (options.scope) {
|
|
scopeIdentifierName('::' + nameToken.value + '::');
|
|
attachScope(label, true);
|
|
}
|
|
|
|
expect('::');
|
|
|
|
flowContext.addLabel(nameToken.value, nameToken);
|
|
return finishNode(ast.labelStatement(label));
|
|
}
|
|
|
|
// break ::= 'break'
|
|
|
|
function parseBreakStatement() {
|
|
return finishNode(ast.breakStatement());
|
|
}
|
|
|
|
// goto ::= 'goto' Name
|
|
|
|
function parseGotoStatement(flowContext) {
|
|
var name = token.value
|
|
, gotoToken = previousToken
|
|
, label = parseIdentifier();
|
|
|
|
flowContext.addGoto(name, gotoToken);
|
|
return finishNode(ast.gotoStatement(label));
|
|
}
|
|
|
|
// do ::= 'do' block 'end'
|
|
|
|
function parseDoStatement(flowContext) {
|
|
if (options.scope) createScope();
|
|
flowContext.pushScope();
|
|
var body = parseBlock(flowContext);
|
|
flowContext.popScope();
|
|
if (options.scope) destroyScope();
|
|
expect('end');
|
|
return finishNode(ast.doStatement(body));
|
|
}
|
|
|
|
// while ::= 'while' exp 'do' block 'end'
|
|
|
|
function parseWhileStatement(flowContext) {
|
|
var condition = parseExpectedExpression(flowContext);
|
|
expect('do');
|
|
if (options.scope) createScope();
|
|
flowContext.pushScope(true);
|
|
var body = parseBlock(flowContext);
|
|
flowContext.popScope();
|
|
if (options.scope) destroyScope();
|
|
expect('end');
|
|
return finishNode(ast.whileStatement(condition, body));
|
|
}
|
|
|
|
// repeat ::= 'repeat' block 'until' exp
|
|
|
|
function parseRepeatStatement(flowContext) {
|
|
if (options.scope) createScope();
|
|
flowContext.pushScope(true);
|
|
var body = parseBlock(flowContext);
|
|
expect('until');
|
|
flowContext.raiseDeferredErrors();
|
|
var condition = parseExpectedExpression(flowContext);
|
|
flowContext.popScope();
|
|
if (options.scope) destroyScope();
|
|
return finishNode(ast.repeatStatement(condition, body));
|
|
}
|
|
|
|
// retstat ::= 'return' [exp {',' exp}] [';']
|
|
|
|
function parseReturnStatement(flowContext) {
|
|
var expressions = [];
|
|
|
|
if ('end' !== token.value) {
|
|
var expression = parseExpression(flowContext);
|
|
if (null != expression) expressions.push(expression);
|
|
while (consume(',')) {
|
|
expression = parseExpectedExpression(flowContext);
|
|
expressions.push(expression);
|
|
}
|
|
consume(';'); // grammar tells us ; is optional here.
|
|
}
|
|
return finishNode(ast.returnStatement(expressions));
|
|
}
|
|
|
|
// if ::= 'if' exp 'then' block {elif} ['else' block] 'end'
|
|
// elif ::= 'elseif' exp 'then' block
|
|
|
|
function parseIfStatement(flowContext) {
|
|
var clauses = []
|
|
, condition
|
|
, body
|
|
, marker;
|
|
|
|
// IfClauses begin at the same location as the parent IfStatement.
|
|
// It ends at the start of `end`, `else`, or `elseif`.
|
|
if (trackLocations) {
|
|
marker = locations[locations.length - 1];
|
|
locations.push(marker);
|
|
}
|
|
condition = parseExpectedExpression(flowContext);
|
|
expect('then');
|
|
if (options.scope) createScope();
|
|
flowContext.pushScope();
|
|
body = parseBlock(flowContext);
|
|
flowContext.popScope();
|
|
if (options.scope) destroyScope();
|
|
clauses.push(finishNode(ast.ifClause(condition, body)));
|
|
|
|
if (trackLocations) marker = createLocationMarker();
|
|
while (consume('elseif')) {
|
|
pushLocation(marker);
|
|
condition = parseExpectedExpression(flowContext);
|
|
expect('then');
|
|
if (options.scope) createScope();
|
|
flowContext.pushScope();
|
|
body = parseBlock(flowContext);
|
|
flowContext.popScope();
|
|
if (options.scope) destroyScope();
|
|
clauses.push(finishNode(ast.elseifClause(condition, body)));
|
|
if (trackLocations) marker = createLocationMarker();
|
|
}
|
|
|
|
if (consume('else')) {
|
|
// Include the `else` in the location of ElseClause.
|
|
if (trackLocations) {
|
|
marker = new Marker(previousToken);
|
|
locations.push(marker);
|
|
}
|
|
if (options.scope) createScope();
|
|
flowContext.pushScope();
|
|
body = parseBlock(flowContext);
|
|
flowContext.popScope();
|
|
if (options.scope) destroyScope();
|
|
clauses.push(finishNode(ast.elseClause(body)));
|
|
}
|
|
|
|
expect('end');
|
|
return finishNode(ast.ifStatement(clauses));
|
|
}
|
|
|
|
// There are two types of for statements, generic and numeric.
|
|
//
|
|
// for ::= Name '=' exp ',' exp [',' exp] 'do' block 'end'
|
|
// for ::= namelist 'in' explist 'do' block 'end'
|
|
// namelist ::= Name {',' Name}
|
|
// explist ::= exp {',' exp}
|
|
|
|
function parseForStatement(flowContext) {
|
|
var variable = parseIdentifier()
|
|
, body;
|
|
|
|
// The start-identifier is local.
|
|
|
|
if (options.scope) {
|
|
createScope();
|
|
scopeIdentifier(variable);
|
|
}
|
|
|
|
// If the first expression is followed by a `=` punctuator, this is a
|
|
// Numeric For Statement.
|
|
if (consume('=')) {
|
|
// Start expression
|
|
var start = parseExpectedExpression(flowContext);
|
|
expect(',');
|
|
// End expression
|
|
var end = parseExpectedExpression(flowContext);
|
|
// Optional step expression
|
|
var step = consume(',') ? parseExpectedExpression(flowContext) : null;
|
|
|
|
expect('do');
|
|
flowContext.pushScope(true);
|
|
body = parseBlock(flowContext);
|
|
flowContext.popScope();
|
|
expect('end');
|
|
if (options.scope) destroyScope();
|
|
|
|
return finishNode(ast.forNumericStatement(variable, start, end, step, body));
|
|
}
|
|
// If not, it's a Generic For Statement
|
|
else {
|
|
// The namelist can contain one or more identifiers.
|
|
var variables = [variable];
|
|
while (consume(',')) {
|
|
variable = parseIdentifier();
|
|
// Each variable in the namelist is locally scoped.
|
|
if (options.scope) scopeIdentifier(variable);
|
|
variables.push(variable);
|
|
}
|
|
expect('in');
|
|
var iterators = [];
|
|
|
|
// One or more expressions in the explist.
|
|
do {
|
|
var expression = parseExpectedExpression(flowContext);
|
|
iterators.push(expression);
|
|
} while (consume(','));
|
|
|
|
expect('do');
|
|
flowContext.pushScope(true);
|
|
body = parseBlock(flowContext);
|
|
flowContext.popScope();
|
|
expect('end');
|
|
if (options.scope) destroyScope();
|
|
|
|
return finishNode(ast.forGenericStatement(variables, iterators, body));
|
|
}
|
|
}
|
|
|
|
// Local statements can either be variable assignments or function
|
|
// definitions. If a function definition is found, it will be delegated to
|
|
// `parseFunctionDeclaration()` with the isLocal flag.
|
|
//
|
|
// This AST structure might change into a local assignment with a function
|
|
// child.
|
|
//
|
|
// local ::= 'local' 'function' Name funcdecl
|
|
// | 'local' Name {',' Name} ['=' exp {',' exp}]
|
|
|
|
function parseLocalStatement(flowContext) {
|
|
var name
|
|
, declToken = previousToken;
|
|
|
|
if (Identifier === token.type) {
|
|
var variables = []
|
|
, init = [];
|
|
|
|
do {
|
|
name = parseIdentifier();
|
|
|
|
variables.push(name);
|
|
flowContext.addLocal(name.name, declToken);
|
|
} while (consume(','));
|
|
|
|
if (consume('=')) {
|
|
do {
|
|
var expression = parseExpectedExpression(flowContext);
|
|
init.push(expression);
|
|
} while (consume(','));
|
|
}
|
|
|
|
// Declarations doesn't exist before the statement has been evaluated.
|
|
// Therefore assignments can't use their declarator. And the identifiers
|
|
// shouldn't be added to the scope until the statement is complete.
|
|
if (options.scope) {
|
|
for (var i = 0, l = variables.length; i < l; ++i) {
|
|
scopeIdentifier(variables[i]);
|
|
}
|
|
}
|
|
|
|
return finishNode(ast.localStatement(variables, init));
|
|
}
|
|
if (consume('function')) {
|
|
name = parseIdentifier();
|
|
flowContext.addLocal(name.name, declToken);
|
|
|
|
if (options.scope) {
|
|
scopeIdentifier(name);
|
|
createScope();
|
|
}
|
|
|
|
// MemberExpressions are not allowed in local function statements.
|
|
return parseFunctionDeclaration(name, true);
|
|
} else {
|
|
raiseUnexpectedToken('<name>', token);
|
|
}
|
|
}
|
|
|
|
// assignment ::= varlist '=' explist
|
|
// var ::= Name | prefixexp '[' exp ']' | prefixexp '.' Name
|
|
// varlist ::= var {',' var}
|
|
// explist ::= exp {',' exp}
|
|
//
|
|
// call ::= callexp
|
|
// callexp ::= prefixexp args | prefixexp ':' Name args
|
|
|
|
function parseAssignmentOrCallStatement(flowContext) {
|
|
// Keep a reference to the previous token for better error messages in case
|
|
// of invalid statement
|
|
var previous = token
|
|
, marker, startMarker;
|
|
var lvalue, base, name;
|
|
|
|
var targets = [];
|
|
|
|
if (trackLocations) startMarker = createLocationMarker();
|
|
|
|
do {
|
|
if (trackLocations) marker = createLocationMarker();
|
|
|
|
if (Identifier === token.type) {
|
|
name = token.value;
|
|
base = parseIdentifier();
|
|
// Set the parent scope.
|
|
if (options.scope) attachScope(base, scopeHasName(name));
|
|
lvalue = true;
|
|
} else if ('(' === token.value) {
|
|
next();
|
|
base = parseExpectedExpression(flowContext);
|
|
expect(')');
|
|
lvalue = false;
|
|
} else {
|
|
return unexpected(token);
|
|
}
|
|
|
|
both: for (;;) {
|
|
var newBase;
|
|
|
|
switch (StringLiteral === token.type ? '"' : token.value) {
|
|
case '.':
|
|
case '[':
|
|
lvalue = true;
|
|
break;
|
|
case ':':
|
|
case '(':
|
|
case '{':
|
|
case '"':
|
|
lvalue = null;
|
|
break;
|
|
default:
|
|
break both;
|
|
}
|
|
|
|
base = parsePrefixExpressionPart(base, marker, flowContext);
|
|
}
|
|
|
|
targets.push(base);
|
|
|
|
if (',' !== token.value)
|
|
break;
|
|
|
|
if (!lvalue) {
|
|
return unexpected(token);
|
|
}
|
|
|
|
next();
|
|
} while (true);
|
|
|
|
if (targets.length === 1 && lvalue === null) {
|
|
pushLocation(marker);
|
|
return finishNode(ast.callStatement(targets[0]));
|
|
} else if (!lvalue) {
|
|
return unexpected(token);
|
|
}
|
|
|
|
expect('=');
|
|
|
|
var values = [];
|
|
|
|
do {
|
|
values.push(parseExpectedExpression(flowContext));
|
|
} while (consume(','));
|
|
|
|
pushLocation(startMarker);
|
|
return finishNode(ast.assignmentStatement(targets, values));
|
|
}
|
|
|
|
// ### Non-statements
|
|
|
|
// Identifier ::= Name
|
|
|
|
function parseIdentifier() {
|
|
markLocation();
|
|
var identifier = token.value;
|
|
if (Identifier !== token.type) raiseUnexpectedToken('<name>', token);
|
|
next();
|
|
return finishNode(ast.identifier(identifier));
|
|
}
|
|
|
|
// Parse the functions parameters and body block. The name should already
|
|
// have been parsed and passed to this declaration function. By separating
|
|
// this we allow for anonymous functions in expressions.
|
|
//
|
|
// For local functions there's a boolean parameter which needs to be set
|
|
// when parsing the declaration.
|
|
//
|
|
// funcdecl ::= '(' [parlist] ')' block 'end'
|
|
// parlist ::= Name {',' Name} | [',' '...'] | '...'
|
|
|
|
function parseFunctionDeclaration(name, isLocal) {
|
|
var flowContext = makeFlowContext();
|
|
flowContext.pushScope();
|
|
|
|
var parameters = [];
|
|
expect('(');
|
|
|
|
// The declaration has arguments
|
|
if (!consume(')')) {
|
|
// Arguments are a comma separated list of identifiers, optionally ending
|
|
// with a vararg.
|
|
while (true) {
|
|
if (Identifier === token.type) {
|
|
var parameter = parseIdentifier();
|
|
// Function parameters are local.
|
|
if (options.scope) scopeIdentifier(parameter);
|
|
|
|
parameters.push(parameter);
|
|
|
|
if (consume(',')) continue;
|
|
}
|
|
// No arguments are allowed after a vararg.
|
|
else if (VarargLiteral === token.type) {
|
|
flowContext.allowVararg = true;
|
|
parameters.push(parsePrimaryExpression(flowContext));
|
|
} else {
|
|
raiseUnexpectedToken('<name> or \'...\'', token);
|
|
}
|
|
expect(')');
|
|
break;
|
|
}
|
|
}
|
|
|
|
var body = parseBlock(flowContext);
|
|
flowContext.popScope();
|
|
expect('end');
|
|
if (options.scope) destroyScope();
|
|
|
|
isLocal = isLocal || false;
|
|
return finishNode(ast.functionStatement(name, parameters, isLocal, body));
|
|
}
|
|
|
|
// Parse the function name as identifiers and member expressions.
|
|
//
|
|
// Name {'.' Name} [':' Name]
|
|
|
|
function parseFunctionName() {
|
|
var base, name, marker;
|
|
|
|
if (trackLocations) marker = createLocationMarker();
|
|
base = parseIdentifier();
|
|
|
|
if (options.scope) {
|
|
attachScope(base, scopeHasName(base.name));
|
|
createScope();
|
|
}
|
|
|
|
while (consume('.')) {
|
|
pushLocation(marker);
|
|
name = parseIdentifier();
|
|
base = finishNode(ast.memberExpression(base, '.', name));
|
|
}
|
|
|
|
if (consume(':')) {
|
|
pushLocation(marker);
|
|
name = parseIdentifier();
|
|
base = finishNode(ast.memberExpression(base, ':', name));
|
|
if (options.scope) scopeIdentifierName('self');
|
|
}
|
|
|
|
return base;
|
|
}
|
|
|
|
// tableconstructor ::= '{' [fieldlist] '}'
|
|
// fieldlist ::= field {fieldsep field} fieldsep
|
|
// field ::= '[' exp ']' '=' exp | Name = 'exp' | exp
|
|
//
|
|
// fieldsep ::= ',' | ';'
|
|
|
|
function parseTableConstructor(flowContext) {
|
|
var fields = []
|
|
, key, value;
|
|
|
|
while (true) {
|
|
markLocation();
|
|
if (Punctuator === token.type && consume('[')) {
|
|
key = parseExpectedExpression(flowContext);
|
|
expect(']');
|
|
expect('=');
|
|
value = parseExpectedExpression(flowContext);
|
|
fields.push(finishNode(ast.tableKey(key, value)));
|
|
} else if (Identifier === token.type) {
|
|
if ('=' === lookahead.value) {
|
|
key = parseIdentifier();
|
|
next();
|
|
value = parseExpectedExpression(flowContext);
|
|
fields.push(finishNode(ast.tableKeyString(key, value)));
|
|
} else {
|
|
value = parseExpectedExpression(flowContext);
|
|
fields.push(finishNode(ast.tableValue(value)));
|
|
}
|
|
} else {
|
|
if (null == (value = parseExpression(flowContext))) {
|
|
locations.pop();
|
|
break;
|
|
}
|
|
fields.push(finishNode(ast.tableValue(value)));
|
|
}
|
|
if (',;'.indexOf(token.value) >= 0) {
|
|
next();
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
expect('}');
|
|
return finishNode(ast.tableConstructorExpression(fields));
|
|
}
|
|
|
|
// Expression parser
|
|
// -----------------
|
|
//
|
|
// Expressions are evaluated and always return a value. If nothing is
|
|
// matched null will be returned.
|
|
//
|
|
// exp ::= (unop exp | primary | prefixexp ) { binop exp }
|
|
//
|
|
// primary ::= nil | false | true | Number | String | '...'
|
|
// | functiondef | tableconstructor
|
|
//
|
|
// prefixexp ::= (Name | '(' exp ')' ) { '[' exp ']'
|
|
// | '.' Name | ':' Name args | args }
|
|
//
|
|
|
|
function parseExpression(flowContext) {
|
|
var expression = parseSubExpression(0, flowContext);
|
|
return expression;
|
|
}
|
|
|
|
// Parse an expression expecting it to be valid.
|
|
|
|
function parseExpectedExpression(flowContext) {
|
|
var expression = parseExpression(flowContext);
|
|
if (null == expression) raiseUnexpectedToken('<expression>', token);
|
|
else return expression;
|
|
}
|
|
|
|
|
|
// Return the precedence priority of the operator.
|
|
//
|
|
// As unary `-` can't be distinguished from binary `-`, unary precedence
|
|
// isn't described in this table but in `parseSubExpression()` itself.
|
|
//
|
|
// As this function gets hit on every expression it's been optimized due to
|
|
// the expensive CompareICStub which took ~8% of the parse time.
|
|
|
|
function binaryPrecedence(operator) {
|
|
var charCode = operator.charCodeAt(0)
|
|
, length = operator.length;
|
|
|
|
if (1 === length) {
|
|
switch (charCode) {
|
|
case 94: return 12; // ^
|
|
case 42: case 47: case 37: return 10; // * / %
|
|
case 43: case 45: return 9; // + -
|
|
case 38: return 6; // &
|
|
case 126: return 5; // ~
|
|
case 124: return 4; // |
|
|
case 60: case 62: return 3; // < >
|
|
}
|
|
} else if (2 === length) {
|
|
switch (charCode) {
|
|
case 47: return 10; // //
|
|
case 46: return 8; // ..
|
|
case 60: case 62:
|
|
if('<<' === operator || '>>' === operator) return 7; // << >>
|
|
return 3; // <= >=
|
|
case 61: case 126: return 3; // == ~=
|
|
case 111: return 1; // or
|
|
}
|
|
} else if (97 === charCode && 'and' === operator) return 2;
|
|
return 0;
|
|
}
|
|
|
|
// Implement an operator-precedence parser to handle binary operator
|
|
// precedence.
|
|
//
|
|
// We use this algorithm because it's compact, it's fast and Lua core uses
|
|
// the same so we can be sure our expressions are parsed in the same manner
|
|
// without excessive amounts of tests.
|
|
//
|
|
// exp ::= (unop exp | primary | prefixexp ) { binop exp }
|
|
|
|
function parseSubExpression(minPrecedence, flowContext) {
|
|
var operator = token.value
|
|
// The left-hand side in binary operations.
|
|
, expression, marker;
|
|
|
|
if (trackLocations) marker = createLocationMarker();
|
|
|
|
// UnaryExpression
|
|
if (isUnary(token)) {
|
|
markLocation();
|
|
next();
|
|
var argument = parseSubExpression(10, flowContext);
|
|
if (argument == null) raiseUnexpectedToken('<expression>', token);
|
|
expression = finishNode(ast.unaryExpression(operator, argument));
|
|
}
|
|
if (null == expression) {
|
|
// PrimaryExpression
|
|
expression = parsePrimaryExpression(flowContext);
|
|
|
|
// PrefixExpression
|
|
if (null == expression) {
|
|
expression = parsePrefixExpression(flowContext);
|
|
}
|
|
}
|
|
// This is not a valid left hand expression.
|
|
if (null == expression) return null;
|
|
|
|
var precedence;
|
|
while (true) {
|
|
operator = token.value;
|
|
|
|
precedence = (Punctuator === token.type || Keyword === token.type) ?
|
|
binaryPrecedence(operator) : 0;
|
|
|
|
if (precedence === 0 || precedence <= minPrecedence) break;
|
|
// Right-hand precedence operators
|
|
if ('^' === operator || '..' === operator) --precedence;
|
|
next();
|
|
var right = parseSubExpression(precedence, flowContext);
|
|
if (null == right) raiseUnexpectedToken('<expression>', token);
|
|
// Push in the marker created before the loop to wrap its entirety.
|
|
if (trackLocations) locations.push(marker);
|
|
expression = finishNode(ast.binaryExpression(operator, expression, right));
|
|
|
|
}
|
|
return expression;
|
|
}
|
|
|
|
// prefixexp ::= prefix {suffix}
|
|
// prefix ::= Name | '(' exp ')'
|
|
// suffix ::= '[' exp ']' | '.' Name | ':' Name args | args
|
|
//
|
|
// args ::= '(' [explist] ')' | tableconstructor | String
|
|
|
|
function parsePrefixExpressionPart(base, marker, flowContext) {
|
|
var expression, identifier;
|
|
|
|
if (Punctuator === token.type) {
|
|
switch (token.value) {
|
|
case '[':
|
|
pushLocation(marker);
|
|
next();
|
|
expression = parseExpectedExpression(flowContext);
|
|
expect(']');
|
|
return finishNode(ast.indexExpression(base, expression));
|
|
case '.':
|
|
pushLocation(marker);
|
|
next();
|
|
identifier = parseIdentifier();
|
|
return finishNode(ast.memberExpression(base, '.', identifier));
|
|
case ':':
|
|
pushLocation(marker);
|
|
next();
|
|
identifier = parseIdentifier();
|
|
base = finishNode(ast.memberExpression(base, ':', identifier));
|
|
// Once a : is found, this has to be a CallExpression, otherwise
|
|
// throw an error.
|
|
pushLocation(marker);
|
|
return parseCallExpression(base, flowContext);
|
|
case '(': case '{': // args
|
|
pushLocation(marker);
|
|
return parseCallExpression(base, flowContext);
|
|
}
|
|
} else if (StringLiteral === token.type) {
|
|
pushLocation(marker);
|
|
return parseCallExpression(base, flowContext);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function parsePrefixExpression(flowContext) {
|
|
var base, name, marker;
|
|
|
|
if (trackLocations) marker = createLocationMarker();
|
|
|
|
// The prefix
|
|
if (Identifier === token.type) {
|
|
name = token.value;
|
|
base = parseIdentifier();
|
|
// Set the parent scope.
|
|
if (options.scope) attachScope(base, scopeHasName(name));
|
|
} else if (consume('(')) {
|
|
base = parseExpectedExpression(flowContext);
|
|
expect(')');
|
|
} else {
|
|
return null;
|
|
}
|
|
|
|
// The suffix
|
|
for (;;) {
|
|
var newBase = parsePrefixExpressionPart(base, marker, flowContext);
|
|
if (newBase === null)
|
|
break;
|
|
base = newBase;
|
|
}
|
|
|
|
return base;
|
|
}
|
|
|
|
// args ::= '(' [explist] ')' | tableconstructor | String
|
|
|
|
function parseCallExpression(base, flowContext) {
|
|
if (Punctuator === token.type) {
|
|
switch (token.value) {
|
|
case '(':
|
|
if (!features.emptyStatement) {
|
|
if (token.line !== previousToken.line)
|
|
raise(null, errors.ambiguousSyntax, token.value);
|
|
}
|
|
next();
|
|
|
|
// List of expressions
|
|
var expressions = [];
|
|
var expression = parseExpression(flowContext);
|
|
if (null != expression) expressions.push(expression);
|
|
while (consume(',')) {
|
|
expression = parseExpectedExpression(flowContext);
|
|
expressions.push(expression);
|
|
}
|
|
|
|
expect(')');
|
|
return finishNode(ast.callExpression(base, expressions));
|
|
|
|
case '{':
|
|
markLocation();
|
|
next();
|
|
var table = parseTableConstructor(flowContext);
|
|
return finishNode(ast.tableCallExpression(base, table));
|
|
}
|
|
} else if (StringLiteral === token.type) {
|
|
return finishNode(ast.stringCallExpression(base, parsePrimaryExpression(flowContext)));
|
|
}
|
|
|
|
raiseUnexpectedToken('function arguments', token);
|
|
}
|
|
|
|
// primary ::= String | Numeric | nil | true | false
|
|
// | functiondef | tableconstructor | '...'
|
|
|
|
function parsePrimaryExpression(flowContext) {
|
|
var literals = StringLiteral | NumericLiteral | BooleanLiteral | NilLiteral | VarargLiteral
|
|
, value = token.value
|
|
, type = token.type
|
|
, marker;
|
|
|
|
if (trackLocations) marker = createLocationMarker();
|
|
|
|
if (type === VarargLiteral && !flowContext.allowVararg) {
|
|
raise(token, errors.cannotUseVararg, token.value);
|
|
}
|
|
|
|
if (type & literals) {
|
|
pushLocation(marker);
|
|
var raw = input.slice(token.range[0], token.range[1]);
|
|
next();
|
|
return finishNode(ast.literal(type, value, raw));
|
|
} else if (Keyword === type && 'function' === value) {
|
|
pushLocation(marker);
|
|
next();
|
|
if (options.scope) createScope();
|
|
return parseFunctionDeclaration(null);
|
|
} else if (consume('{')) {
|
|
pushLocation(marker);
|
|
return parseTableConstructor(flowContext);
|
|
}
|
|
}
|
|
|
|
// Parser
|
|
// ------
|
|
|
|
// Export the main parser.
|
|
//
|
|
// - `wait` Hold parsing until end() is called. Defaults to false
|
|
// - `comments` Store comments. Defaults to true.
|
|
// - `scope` Track identifier scope. Defaults to false.
|
|
// - `locations` Store location information. Defaults to false.
|
|
// - `ranges` Store the start and end character locations. Defaults to
|
|
// false.
|
|
// - `onCreateNode` Callback which will be invoked when a syntax node is
|
|
// created.
|
|
// - `onCreateScope` Callback which will be invoked when a new scope is
|
|
// created.
|
|
// - `onDestroyScope` Callback which will be invoked when the current scope
|
|
// is destroyed.
|
|
//
|
|
// Example:
|
|
//
|
|
// var parser = require('luaparser');
|
|
// parser.parse('i = 0');
|
|
|
|
exports.parse = parse;
|
|
|
|
var versionFeatures = {
|
|
'5.1': {
|
|
},
|
|
'5.2': {
|
|
labels: true,
|
|
emptyStatement: true,
|
|
hexEscapes: true,
|
|
skipWhitespaceEscape: true,
|
|
strictEscapes: true,
|
|
relaxedBreak: true
|
|
},
|
|
'5.3': {
|
|
labels: true,
|
|
emptyStatement: true,
|
|
hexEscapes: true,
|
|
skipWhitespaceEscape: true,
|
|
strictEscapes: true,
|
|
unicodeEscapes: true,
|
|
bitwiseOperators: true,
|
|
integerDivision: true,
|
|
relaxedBreak: true
|
|
},
|
|
'LuaJIT': {
|
|
// XXX: LuaJIT language features may depend on compilation options; may need to
|
|
// rethink how to handle this. Specifically, there is a LUAJIT_ENABLE_LUA52COMPAT
|
|
// that removes contextual goto. Maybe add 'LuaJIT-5.2compat' as well?
|
|
labels: true,
|
|
contextualGoto: true,
|
|
hexEscapes: true,
|
|
skipWhitespaceEscape: true,
|
|
strictEscapes: true,
|
|
unicodeEscapes: true,
|
|
imaginaryNumbers: true,
|
|
integerSuffixes: true
|
|
}
|
|
};
|
|
|
|
function parse(_input, _options) {
|
|
if ('undefined' === typeof _options && 'object' === typeof _input) {
|
|
_options = _input;
|
|
_input = undefined;
|
|
}
|
|
if (!_options) _options = {};
|
|
|
|
input = _input || '';
|
|
options = assign({}, defaultOptions, _options);
|
|
|
|
// Rewind the lexer
|
|
index = 0;
|
|
line = 1;
|
|
lineStart = 0;
|
|
length = input.length;
|
|
// When tracking identifier scope, initialize with an empty scope.
|
|
scopes = [[]];
|
|
scopeDepth = 0;
|
|
globals = [];
|
|
locations = [];
|
|
|
|
if (!Object.prototype.hasOwnProperty.call(versionFeatures, options.luaVersion)) {
|
|
throw new Error(sprintf("Lua version '%1' not supported", options.luaVersion));
|
|
}
|
|
|
|
features = assign({}, versionFeatures[options.luaVersion]);
|
|
if (options.extendedIdentifiers !== void 0)
|
|
features.extendedIdentifiers = !!options.extendedIdentifiers;
|
|
|
|
if (!Object.prototype.hasOwnProperty.call(encodingModes, options.encodingMode)) {
|
|
throw new Error(sprintf("Encoding mode '%1' not supported", options.encodingMode));
|
|
}
|
|
|
|
encodingMode = encodingModes[options.encodingMode];
|
|
|
|
if (options.comments) comments = [];
|
|
if (!options.wait) return end();
|
|
return exports;
|
|
}
|
|
|
|
// Write to the source code buffer without beginning the parse.
|
|
exports.write = write;
|
|
|
|
function write(_input) {
|
|
input += String(_input);
|
|
length = input.length;
|
|
return exports;
|
|
}
|
|
|
|
// Send an EOF and begin parsing.
|
|
exports.end = end;
|
|
|
|
function end(_input) {
|
|
if ('undefined' !== typeof _input) write(_input);
|
|
|
|
// Ignore shebangs.
|
|
if (input && input.substr(0, 2) === '#!') input = input.replace(/^.*/, function (line) {
|
|
return line.replace(/./g, ' ');
|
|
});
|
|
|
|
length = input.length;
|
|
trackLocations = options.locations || options.ranges;
|
|
// Initialize with a lookahead token.
|
|
lookahead = lex();
|
|
|
|
var chunk = parseChunk();
|
|
if (options.comments) chunk.comments = comments;
|
|
if (options.scope) chunk.globals = globals;
|
|
|
|
/* istanbul ignore if */
|
|
if (locations.length > 0)
|
|
throw new Error('Location tracking failed. This is most likely a bug in luaparse');
|
|
|
|
return chunk;
|
|
}
|
|
|
|
}));
|
|
/* vim: set sw=2 ts=2 et tw=79 : */
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2372:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var numberIsNaN = function (value) {
|
|
return value !== value;
|
|
};
|
|
|
|
module.exports = function is(a, b) {
|
|
if (a === 0 && b === 0) {
|
|
return 1 / a === 1 / b;
|
|
}
|
|
if (a === b) {
|
|
return true;
|
|
}
|
|
if (numberIsNaN(a) && numberIsNaN(b)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5968:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var define = __webpack_require__(1857);
|
|
var callBind = __webpack_require__(8498);
|
|
|
|
var implementation = __webpack_require__(2372);
|
|
var getPolyfill = __webpack_require__(1937);
|
|
var shim = __webpack_require__(5087);
|
|
|
|
var polyfill = callBind(getPolyfill(), Object);
|
|
|
|
define(polyfill, {
|
|
getPolyfill: getPolyfill,
|
|
implementation: implementation,
|
|
shim: shim
|
|
});
|
|
|
|
module.exports = polyfill;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1937:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var implementation = __webpack_require__(2372);
|
|
|
|
module.exports = function getPolyfill() {
|
|
return typeof Object.is === 'function' ? Object.is : implementation;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5087:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var getPolyfill = __webpack_require__(1937);
|
|
var define = __webpack_require__(1857);
|
|
|
|
module.exports = function shimObjectIs() {
|
|
var polyfill = getPolyfill();
|
|
define(Object, { is: polyfill }, {
|
|
is: function testObjectIs() {
|
|
return Object.is !== polyfill;
|
|
}
|
|
});
|
|
return polyfill;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8160:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var keysShim;
|
|
if (!Object.keys) {
|
|
// modified from https://github.com/es-shims/es5-shim
|
|
var has = Object.prototype.hasOwnProperty;
|
|
var toStr = Object.prototype.toString;
|
|
var isArgs = __webpack_require__(968); // eslint-disable-line global-require
|
|
var isEnumerable = Object.prototype.propertyIsEnumerable;
|
|
var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
|
|
var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
|
|
var dontEnums = [
|
|
'toString',
|
|
'toLocaleString',
|
|
'valueOf',
|
|
'hasOwnProperty',
|
|
'isPrototypeOf',
|
|
'propertyIsEnumerable',
|
|
'constructor'
|
|
];
|
|
var equalsConstructorPrototype = function (o) {
|
|
var ctor = o.constructor;
|
|
return ctor && ctor.prototype === o;
|
|
};
|
|
var excludedKeys = {
|
|
$applicationCache: true,
|
|
$console: true,
|
|
$external: true,
|
|
$frame: true,
|
|
$frameElement: true,
|
|
$frames: true,
|
|
$innerHeight: true,
|
|
$innerWidth: true,
|
|
$onmozfullscreenchange: true,
|
|
$onmozfullscreenerror: true,
|
|
$outerHeight: true,
|
|
$outerWidth: true,
|
|
$pageXOffset: true,
|
|
$pageYOffset: true,
|
|
$parent: true,
|
|
$scrollLeft: true,
|
|
$scrollTop: true,
|
|
$scrollX: true,
|
|
$scrollY: true,
|
|
$self: true,
|
|
$webkitIndexedDB: true,
|
|
$webkitStorageInfo: true,
|
|
$window: true
|
|
};
|
|
var hasAutomationEqualityBug = (function () {
|
|
/* global window */
|
|
if (typeof window === 'undefined') { return false; }
|
|
for (var k in window) {
|
|
try {
|
|
if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
|
|
try {
|
|
equalsConstructorPrototype(window[k]);
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}());
|
|
var equalsConstructorPrototypeIfNotBuggy = function (o) {
|
|
/* global window */
|
|
if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
|
|
return equalsConstructorPrototype(o);
|
|
}
|
|
try {
|
|
return equalsConstructorPrototype(o);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
keysShim = function keys(object) {
|
|
var isObject = object !== null && typeof object === 'object';
|
|
var isFunction = toStr.call(object) === '[object Function]';
|
|
var isArguments = isArgs(object);
|
|
var isString = isObject && toStr.call(object) === '[object String]';
|
|
var theKeys = [];
|
|
|
|
if (!isObject && !isFunction && !isArguments) {
|
|
throw new TypeError('Object.keys called on a non-object');
|
|
}
|
|
|
|
var skipProto = hasProtoEnumBug && isFunction;
|
|
if (isString && object.length > 0 && !has.call(object, 0)) {
|
|
for (var i = 0; i < object.length; ++i) {
|
|
theKeys.push(String(i));
|
|
}
|
|
}
|
|
|
|
if (isArguments && object.length > 0) {
|
|
for (var j = 0; j < object.length; ++j) {
|
|
theKeys.push(String(j));
|
|
}
|
|
} else {
|
|
for (var name in object) {
|
|
if (!(skipProto && name === 'prototype') && has.call(object, name)) {
|
|
theKeys.push(String(name));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hasDontEnumBug) {
|
|
var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
|
|
|
|
for (var k = 0; k < dontEnums.length; ++k) {
|
|
if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
|
|
theKeys.push(dontEnums[k]);
|
|
}
|
|
}
|
|
}
|
|
return theKeys;
|
|
};
|
|
}
|
|
module.exports = keysShim;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9228:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var slice = Array.prototype.slice;
|
|
var isArgs = __webpack_require__(968);
|
|
|
|
var origKeys = Object.keys;
|
|
var keysShim = origKeys ? function keys(o) { return origKeys(o); } : __webpack_require__(8160);
|
|
|
|
var originalKeys = Object.keys;
|
|
|
|
keysShim.shim = function shimObjectKeys() {
|
|
if (Object.keys) {
|
|
var keysWorksWithArguments = (function () {
|
|
// Safari 5.0 bug
|
|
var args = Object.keys(arguments);
|
|
return args && args.length === arguments.length;
|
|
}(1, 2));
|
|
if (!keysWorksWithArguments) {
|
|
Object.keys = function keys(object) { // eslint-disable-line func-name-matching
|
|
if (isArgs(object)) {
|
|
return originalKeys(slice.call(object));
|
|
}
|
|
return originalKeys(object);
|
|
};
|
|
}
|
|
} else {
|
|
Object.keys = keysShim;
|
|
}
|
|
return Object.keys || keysShim;
|
|
};
|
|
|
|
module.exports = keysShim;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 968:
|
|
/***/ ((module) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var toStr = Object.prototype.toString;
|
|
|
|
module.exports = function isArguments(value) {
|
|
var str = toStr.call(value);
|
|
var isArgs = str === '[object Arguments]';
|
|
if (!isArgs) {
|
|
isArgs = str !== '[object Array]' &&
|
|
value !== null &&
|
|
typeof value === 'object' &&
|
|
typeof value.length === 'number' &&
|
|
value.length >= 0 &&
|
|
toStr.call(value.callee) === '[object Function]';
|
|
}
|
|
return isArgs;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9907:
|
|
/***/ ((module) => {
|
|
|
|
// shim for using process in browser
|
|
var process = module.exports = {};
|
|
|
|
// cached from whatever global is present so that test runners that stub it
|
|
// don't break things. But we need to wrap it in a try catch in case it is
|
|
// wrapped in strict mode code which doesn't define any globals. It's inside a
|
|
// function because try/catches deoptimize in certain engines.
|
|
|
|
var cachedSetTimeout;
|
|
var cachedClearTimeout;
|
|
|
|
function defaultSetTimout() {
|
|
throw new Error('setTimeout has not been defined');
|
|
}
|
|
function defaultClearTimeout () {
|
|
throw new Error('clearTimeout has not been defined');
|
|
}
|
|
(function () {
|
|
try {
|
|
if (typeof setTimeout === 'function') {
|
|
cachedSetTimeout = setTimeout;
|
|
} else {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
} catch (e) {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
try {
|
|
if (typeof clearTimeout === 'function') {
|
|
cachedClearTimeout = clearTimeout;
|
|
} else {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} catch (e) {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} ())
|
|
function runTimeout(fun) {
|
|
if (cachedSetTimeout === setTimeout) {
|
|
//normal enviroments in sane situations
|
|
return setTimeout(fun, 0);
|
|
}
|
|
// if setTimeout wasn't available but was latter defined
|
|
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
|
cachedSetTimeout = setTimeout;
|
|
return setTimeout(fun, 0);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedSetTimeout(fun, 0);
|
|
} catch(e){
|
|
try {
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
return cachedSetTimeout.call(null, fun, 0);
|
|
} catch(e){
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
|
return cachedSetTimeout.call(this, fun, 0);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
function runClearTimeout(marker) {
|
|
if (cachedClearTimeout === clearTimeout) {
|
|
//normal enviroments in sane situations
|
|
return clearTimeout(marker);
|
|
}
|
|
// if clearTimeout wasn't available but was latter defined
|
|
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
|
cachedClearTimeout = clearTimeout;
|
|
return clearTimeout(marker);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedClearTimeout(marker);
|
|
} catch (e){
|
|
try {
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
return cachedClearTimeout.call(null, marker);
|
|
} catch (e){
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
|
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
|
return cachedClearTimeout.call(this, marker);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
var queue = [];
|
|
var draining = false;
|
|
var currentQueue;
|
|
var queueIndex = -1;
|
|
|
|
function cleanUpNextTick() {
|
|
if (!draining || !currentQueue) {
|
|
return;
|
|
}
|
|
draining = false;
|
|
if (currentQueue.length) {
|
|
queue = currentQueue.concat(queue);
|
|
} else {
|
|
queueIndex = -1;
|
|
}
|
|
if (queue.length) {
|
|
drainQueue();
|
|
}
|
|
}
|
|
|
|
function drainQueue() {
|
|
if (draining) {
|
|
return;
|
|
}
|
|
var timeout = runTimeout(cleanUpNextTick);
|
|
draining = true;
|
|
|
|
var len = queue.length;
|
|
while(len) {
|
|
currentQueue = queue;
|
|
queue = [];
|
|
while (++queueIndex < len) {
|
|
if (currentQueue) {
|
|
currentQueue[queueIndex].run();
|
|
}
|
|
}
|
|
queueIndex = -1;
|
|
len = queue.length;
|
|
}
|
|
currentQueue = null;
|
|
draining = false;
|
|
runClearTimeout(timeout);
|
|
}
|
|
|
|
process.nextTick = function (fun) {
|
|
var args = new Array(arguments.length - 1);
|
|
if (arguments.length > 1) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
args[i - 1] = arguments[i];
|
|
}
|
|
}
|
|
queue.push(new Item(fun, args));
|
|
if (queue.length === 1 && !draining) {
|
|
runTimeout(drainQueue);
|
|
}
|
|
};
|
|
|
|
// v8 likes predictible objects
|
|
function Item(fun, array) {
|
|
this.fun = fun;
|
|
this.array = array;
|
|
}
|
|
Item.prototype.run = function () {
|
|
this.fun.apply(null, this.array);
|
|
};
|
|
process.title = 'browser';
|
|
process.browser = true;
|
|
process.env = {};
|
|
process.argv = [];
|
|
process.version = ''; // empty string to avoid regexp issues
|
|
process.versions = {};
|
|
|
|
function noop() {}
|
|
|
|
process.on = noop;
|
|
process.addListener = noop;
|
|
process.once = noop;
|
|
process.off = noop;
|
|
process.removeListener = noop;
|
|
process.removeAllListeners = noop;
|
|
process.emit = noop;
|
|
process.prependListener = noop;
|
|
process.prependOnceListener = noop;
|
|
|
|
process.listeners = function (name) { return [] }
|
|
|
|
process.binding = function (name) {
|
|
throw new Error('process.binding is not supported');
|
|
};
|
|
|
|
process.cwd = function () { return '/' };
|
|
process.chdir = function (dir) {
|
|
throw new Error('process.chdir is not supported');
|
|
};
|
|
process.umask = function() { return 0; };
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6108:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var GetIntrinsic = __webpack_require__(528);
|
|
var define = __webpack_require__(686);
|
|
var hasDescriptors = __webpack_require__(7239)();
|
|
var gOPD = __webpack_require__(9336);
|
|
|
|
var $TypeError = __webpack_require__(3468);
|
|
var $floor = GetIntrinsic('%Math.floor%');
|
|
|
|
/** @type {import('.')} */
|
|
module.exports = function setFunctionLength(fn, length) {
|
|
if (typeof fn !== 'function') {
|
|
throw new $TypeError('`fn` is not a function');
|
|
}
|
|
if (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) {
|
|
throw new $TypeError('`length` must be a positive 32-bit integer');
|
|
}
|
|
|
|
var loose = arguments.length > 2 && !!arguments[2];
|
|
|
|
var functionLengthIsConfigurable = true;
|
|
var functionLengthIsWritable = true;
|
|
if ('length' in fn && gOPD) {
|
|
var desc = gOPD(fn, 'length');
|
|
if (desc && !desc.configurable) {
|
|
functionLengthIsConfigurable = false;
|
|
}
|
|
if (desc && !desc.writable) {
|
|
functionLengthIsWritable = false;
|
|
}
|
|
}
|
|
|
|
if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
|
|
if (hasDescriptors) {
|
|
define(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true);
|
|
} else {
|
|
define(/** @type {Parameters<define>[0]} */ (fn), 'length', length);
|
|
}
|
|
}
|
|
return fn;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2125:
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ BaseService: () => (/* binding */ BaseService)
|
|
/* harmony export */ });
|
|
/* harmony import */ var vscode_languageserver_protocol__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5501);
|
|
/* harmony import */ var vscode_languageserver_protocol__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(vscode_languageserver_protocol__WEBPACK_IMPORTED_MODULE_0__);
|
|
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7770);
|
|
/* harmony import */ var vscode_languageserver_textdocument__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8041);
|
|
function _define_property(obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
|
|
|
|
class BaseService {
|
|
addDocument(document) {
|
|
this.documents[document.uri] = vscode_languageserver_textdocument__WEBPACK_IMPORTED_MODULE_1__/* .TextDocument */ .V.create(document.uri, document.languageId, document.version, document.text);
|
|
}
|
|
getDocument(uri) {
|
|
return this.documents[uri];
|
|
}
|
|
removeDocument(document) {
|
|
delete this.documents[document.uri];
|
|
if (this.options[document.uri]) {
|
|
delete this.options[document.uri];
|
|
}
|
|
}
|
|
getDocumentValue(uri) {
|
|
var _this_getDocument;
|
|
return (_this_getDocument = this.getDocument(uri)) === null || _this_getDocument === void 0 ? void 0 : _this_getDocument.getText();
|
|
}
|
|
setValue(identifier, value) {
|
|
let document = this.getDocument(identifier.uri);
|
|
if (document) {
|
|
document = vscode_languageserver_textdocument__WEBPACK_IMPORTED_MODULE_1__/* .TextDocument */ .V.create(document.uri, document.languageId, document.version, value);
|
|
this.documents[document.uri] = document;
|
|
}
|
|
}
|
|
setGlobalOptions(options) {
|
|
this.globalOptions = options !== null && options !== void 0 ? options : {};
|
|
}
|
|
setWorkspace(workspaceUri) {
|
|
this.workspaceUri = workspaceUri;
|
|
}
|
|
setOptions(documentUri, options, merge = false) {
|
|
this.options[documentUri] = merge ? (0,_utils__WEBPACK_IMPORTED_MODULE_2__/* .mergeObjects */ .rL)(options, this.options[documentUri]) : options;
|
|
}
|
|
getOption(documentUri, optionName) {
|
|
if (this.options[documentUri] && this.options[documentUri][optionName]) {
|
|
return this.options[documentUri][optionName];
|
|
} else {
|
|
return this.globalOptions[optionName];
|
|
}
|
|
}
|
|
applyDeltas(identifier, deltas) {
|
|
let document = this.getDocument(identifier.uri);
|
|
if (document) vscode_languageserver_textdocument__WEBPACK_IMPORTED_MODULE_1__/* .TextDocument */ .V.update(document, deltas, identifier.version);
|
|
}
|
|
async doComplete(document, position) {
|
|
return null;
|
|
}
|
|
async doHover(document, position) {
|
|
return null;
|
|
}
|
|
async doResolve(item) {
|
|
return null;
|
|
}
|
|
async doValidation(document) {
|
|
return [];
|
|
}
|
|
format(document, range, options) {
|
|
return Promise.resolve([]);
|
|
}
|
|
async provideSignatureHelp(document, position) {
|
|
return null;
|
|
}
|
|
async findDocumentHighlights(document, position) {
|
|
return [];
|
|
}
|
|
get optionsToFilterDiagnostics() {
|
|
var _this_globalOptions_errorCodesToIgnore, _this_globalOptions_errorCodesToTreatAsWarning, _this_globalOptions_errorCodesToTreatAsInfo, _this_globalOptions_errorMessagesToIgnore, _this_globalOptions_errorMessagesToTreatAsWarning, _this_globalOptions_errorMessagesToTreatAsInfo;
|
|
return {
|
|
errorCodesToIgnore: (_this_globalOptions_errorCodesToIgnore = this.globalOptions.errorCodesToIgnore) !== null && _this_globalOptions_errorCodesToIgnore !== void 0 ? _this_globalOptions_errorCodesToIgnore : [],
|
|
errorCodesToTreatAsWarning: (_this_globalOptions_errorCodesToTreatAsWarning = this.globalOptions.errorCodesToTreatAsWarning) !== null && _this_globalOptions_errorCodesToTreatAsWarning !== void 0 ? _this_globalOptions_errorCodesToTreatAsWarning : [],
|
|
errorCodesToTreatAsInfo: (_this_globalOptions_errorCodesToTreatAsInfo = this.globalOptions.errorCodesToTreatAsInfo) !== null && _this_globalOptions_errorCodesToTreatAsInfo !== void 0 ? _this_globalOptions_errorCodesToTreatAsInfo : [],
|
|
errorMessagesToIgnore: (_this_globalOptions_errorMessagesToIgnore = this.globalOptions.errorMessagesToIgnore) !== null && _this_globalOptions_errorMessagesToIgnore !== void 0 ? _this_globalOptions_errorMessagesToIgnore : [],
|
|
errorMessagesToTreatAsWarning: (_this_globalOptions_errorMessagesToTreatAsWarning = this.globalOptions.errorMessagesToTreatAsWarning) !== null && _this_globalOptions_errorMessagesToTreatAsWarning !== void 0 ? _this_globalOptions_errorMessagesToTreatAsWarning : [],
|
|
errorMessagesToTreatAsInfo: (_this_globalOptions_errorMessagesToTreatAsInfo = this.globalOptions.errorMessagesToTreatAsInfo) !== null && _this_globalOptions_errorMessagesToTreatAsInfo !== void 0 ? _this_globalOptions_errorMessagesToTreatAsInfo : []
|
|
};
|
|
}
|
|
getSemanticTokens(document, range) {
|
|
return Promise.resolve(null);
|
|
}
|
|
dispose() {
|
|
return Promise.resolve();
|
|
}
|
|
closeConnection() {
|
|
return Promise.resolve();
|
|
}
|
|
getCodeActions(document, range, context) {
|
|
return Promise.resolve(null);
|
|
}
|
|
executeCommand(command, args) {
|
|
return Promise.resolve(null);
|
|
}
|
|
sendAppliedResult(result, callbackId) {}
|
|
constructor(mode, workspaceUri){
|
|
_define_property(this, "serviceName", void 0);
|
|
_define_property(this, "mode", void 0);
|
|
_define_property(this, "documents", {});
|
|
_define_property(this, "options", {});
|
|
_define_property(this, "globalOptions", {});
|
|
_define_property(this, "serviceData", void 0);
|
|
_define_property(this, "serviceCapabilities", {});
|
|
_define_property(this, "workspaceUri", void 0);
|
|
_define_property(this, "clientCapabilities", {
|
|
textDocument: {
|
|
diagnostic: {
|
|
dynamicRegistration: true,
|
|
relatedDocumentSupport: true
|
|
},
|
|
publishDiagnostics: {
|
|
relatedInformation: true,
|
|
versionSupport: false,
|
|
tagSupport: {
|
|
valueSet: [
|
|
vscode_languageserver_protocol__WEBPACK_IMPORTED_MODULE_0__.DiagnosticTag.Unnecessary,
|
|
vscode_languageserver_protocol__WEBPACK_IMPORTED_MODULE_0__.DiagnosticTag.Deprecated
|
|
]
|
|
}
|
|
},
|
|
hover: {
|
|
dynamicRegistration: true,
|
|
contentFormat: [
|
|
'markdown',
|
|
'plaintext'
|
|
]
|
|
},
|
|
synchronization: {
|
|
dynamicRegistration: true,
|
|
willSave: false,
|
|
didSave: false,
|
|
willSaveWaitUntil: false
|
|
},
|
|
formatting: {
|
|
dynamicRegistration: true
|
|
},
|
|
completion: {
|
|
dynamicRegistration: true,
|
|
completionItem: {
|
|
snippetSupport: true,
|
|
commitCharactersSupport: false,
|
|
documentationFormat: [
|
|
'markdown',
|
|
'plaintext'
|
|
],
|
|
deprecatedSupport: false,
|
|
preselectSupport: false
|
|
},
|
|
contextSupport: false
|
|
},
|
|
signatureHelp: {
|
|
signatureInformation: {
|
|
documentationFormat: [
|
|
'markdown',
|
|
'plaintext'
|
|
],
|
|
activeParameterSupport: true
|
|
}
|
|
},
|
|
documentHighlight: {
|
|
dynamicRegistration: true
|
|
},
|
|
semanticTokens: {
|
|
multilineTokenSupport: false,
|
|
overlappingTokenSupport: false,
|
|
tokenTypes: [],
|
|
tokenModifiers: [],
|
|
formats: [
|
|
"relative"
|
|
],
|
|
requests: {
|
|
full: {
|
|
delta: false
|
|
},
|
|
range: true
|
|
},
|
|
augmentsSyntaxTokens: true
|
|
},
|
|
codeAction: {
|
|
dynamicRegistration: true
|
|
}
|
|
},
|
|
workspace: {
|
|
didChangeConfiguration: {
|
|
dynamicRegistration: true
|
|
},
|
|
executeCommand: {
|
|
dynamicRegistration: true
|
|
},
|
|
applyEdit: true,
|
|
workspaceEdit: {
|
|
failureHandling: "abort",
|
|
normalizesLineEndings: false,
|
|
documentChanges: false
|
|
}
|
|
}
|
|
});
|
|
this.mode = mode;
|
|
this.workspaceUri = workspaceUri;
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7770:
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ Tk: () => (/* binding */ checkValueAgainstRegexpArray),
|
|
/* harmony export */ rL: () => (/* binding */ mergeObjects)
|
|
/* harmony export */ });
|
|
/* unused harmony exports notEmpty, mergeRanges, convertToUri */
|
|
|
|
function mergeObjects(obj1, obj2, excludeUndefined = false) {
|
|
if (!obj1) return obj2;
|
|
if (!obj2) return obj1;
|
|
if (excludeUndefined) {
|
|
obj1 = excludeUndefinedValues(obj1);
|
|
obj2 = excludeUndefinedValues(obj2);
|
|
}
|
|
const mergedObjects = {
|
|
...obj2,
|
|
...obj1
|
|
}; // Give priority to obj1 values by spreading obj2 first, then obj1
|
|
for (const key of Object.keys(mergedObjects)){
|
|
if (obj1[key] && obj2[key]) {
|
|
if (Array.isArray(obj1[key])) {
|
|
mergedObjects[key] = obj1[key].concat(obj2[key]);
|
|
} else if (Array.isArray(obj2[key])) {
|
|
mergedObjects[key] = obj2[key].concat(obj1[key]);
|
|
} else if (typeof obj1[key] === 'object' && typeof obj2[key] === 'object') {
|
|
mergedObjects[key] = mergeObjects(obj1[key], obj2[key]);
|
|
}
|
|
}
|
|
}
|
|
return mergedObjects;
|
|
}
|
|
function excludeUndefinedValues(obj) {
|
|
const filteredEntries = Object.entries(obj).filter(([_, value])=>value !== undefined);
|
|
return Object.fromEntries(filteredEntries);
|
|
}
|
|
function notEmpty(value) {
|
|
return value !== null && value !== undefined;
|
|
}
|
|
//taken with small changes from ace-code
|
|
function mergeRanges(ranges) {
|
|
var list = ranges;
|
|
list = list.sort(function(a, b) {
|
|
return comparePoints(a.start, b.start);
|
|
});
|
|
var next = list[0], range;
|
|
for(var i = 1; i < list.length; i++){
|
|
range = next;
|
|
next = list[i];
|
|
var cmp = comparePoints(range.end, next.start);
|
|
if (cmp < 0) continue;
|
|
if (cmp == 0 && !range.isEmpty() && !next.isEmpty()) continue;
|
|
if (comparePoints(range.end, next.end) < 0) {
|
|
range.end.row = next.end.row;
|
|
range.end.column = next.end.column;
|
|
}
|
|
list.splice(i, 1);
|
|
next = range;
|
|
i--;
|
|
}
|
|
return list;
|
|
}
|
|
function comparePoints(p1, p2) {
|
|
return p1.row - p2.row || p1.column - p2.column;
|
|
}
|
|
function checkValueAgainstRegexpArray(value, regexpArray) {
|
|
if (!regexpArray) {
|
|
return false;
|
|
}
|
|
for(let i = 0; i < regexpArray.length; i++){
|
|
if (regexpArray[i].test(value)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function convertToUri(filePath) {
|
|
//already URI
|
|
if (filePath.startsWith("file:///")) {
|
|
return filePath;
|
|
}
|
|
return URI.file(filePath).toString();
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5272:
|
|
/***/ ((module) => {
|
|
|
|
module.exports = function isBuffer(arg) {
|
|
return arg && typeof arg === 'object'
|
|
&& typeof arg.copy === 'function'
|
|
&& typeof arg.fill === 'function'
|
|
&& typeof arg.readUInt8 === 'function';
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1531:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
// Currently in sync with Node.js lib/internal/util/types.js
|
|
// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
|
|
|
|
|
|
|
|
var isArgumentsObject = __webpack_require__(5387);
|
|
var isGeneratorFunction = __webpack_require__(2625);
|
|
var whichTypedArray = __webpack_require__(2730);
|
|
var isTypedArray = __webpack_require__(5943);
|
|
|
|
function uncurryThis(f) {
|
|
return f.call.bind(f);
|
|
}
|
|
|
|
var BigIntSupported = typeof BigInt !== 'undefined';
|
|
var SymbolSupported = typeof Symbol !== 'undefined';
|
|
|
|
var ObjectToString = uncurryThis(Object.prototype.toString);
|
|
|
|
var numberValue = uncurryThis(Number.prototype.valueOf);
|
|
var stringValue = uncurryThis(String.prototype.valueOf);
|
|
var booleanValue = uncurryThis(Boolean.prototype.valueOf);
|
|
|
|
if (BigIntSupported) {
|
|
var bigIntValue = uncurryThis(BigInt.prototype.valueOf);
|
|
}
|
|
|
|
if (SymbolSupported) {
|
|
var symbolValue = uncurryThis(Symbol.prototype.valueOf);
|
|
}
|
|
|
|
function checkBoxedPrimitive(value, prototypeValueOf) {
|
|
if (typeof value !== 'object') {
|
|
return false;
|
|
}
|
|
try {
|
|
prototypeValueOf(value);
|
|
return true;
|
|
} catch(e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
exports.isArgumentsObject = isArgumentsObject;
|
|
exports.isGeneratorFunction = isGeneratorFunction;
|
|
exports.isTypedArray = isTypedArray;
|
|
|
|
// Taken from here and modified for better browser support
|
|
// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js
|
|
function isPromise(input) {
|
|
return (
|
|
(
|
|
typeof Promise !== 'undefined' &&
|
|
input instanceof Promise
|
|
) ||
|
|
(
|
|
input !== null &&
|
|
typeof input === 'object' &&
|
|
typeof input.then === 'function' &&
|
|
typeof input.catch === 'function'
|
|
)
|
|
);
|
|
}
|
|
exports.isPromise = isPromise;
|
|
|
|
function isArrayBufferView(value) {
|
|
if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {
|
|
return ArrayBuffer.isView(value);
|
|
}
|
|
|
|
return (
|
|
isTypedArray(value) ||
|
|
isDataView(value)
|
|
);
|
|
}
|
|
exports.isArrayBufferView = isArrayBufferView;
|
|
|
|
|
|
function isUint8Array(value) {
|
|
return whichTypedArray(value) === 'Uint8Array';
|
|
}
|
|
exports.isUint8Array = isUint8Array;
|
|
|
|
function isUint8ClampedArray(value) {
|
|
return whichTypedArray(value) === 'Uint8ClampedArray';
|
|
}
|
|
exports.isUint8ClampedArray = isUint8ClampedArray;
|
|
|
|
function isUint16Array(value) {
|
|
return whichTypedArray(value) === 'Uint16Array';
|
|
}
|
|
exports.isUint16Array = isUint16Array;
|
|
|
|
function isUint32Array(value) {
|
|
return whichTypedArray(value) === 'Uint32Array';
|
|
}
|
|
exports.isUint32Array = isUint32Array;
|
|
|
|
function isInt8Array(value) {
|
|
return whichTypedArray(value) === 'Int8Array';
|
|
}
|
|
exports.isInt8Array = isInt8Array;
|
|
|
|
function isInt16Array(value) {
|
|
return whichTypedArray(value) === 'Int16Array';
|
|
}
|
|
exports.isInt16Array = isInt16Array;
|
|
|
|
function isInt32Array(value) {
|
|
return whichTypedArray(value) === 'Int32Array';
|
|
}
|
|
exports.isInt32Array = isInt32Array;
|
|
|
|
function isFloat32Array(value) {
|
|
return whichTypedArray(value) === 'Float32Array';
|
|
}
|
|
exports.isFloat32Array = isFloat32Array;
|
|
|
|
function isFloat64Array(value) {
|
|
return whichTypedArray(value) === 'Float64Array';
|
|
}
|
|
exports.isFloat64Array = isFloat64Array;
|
|
|
|
function isBigInt64Array(value) {
|
|
return whichTypedArray(value) === 'BigInt64Array';
|
|
}
|
|
exports.isBigInt64Array = isBigInt64Array;
|
|
|
|
function isBigUint64Array(value) {
|
|
return whichTypedArray(value) === 'BigUint64Array';
|
|
}
|
|
exports.isBigUint64Array = isBigUint64Array;
|
|
|
|
function isMapToString(value) {
|
|
return ObjectToString(value) === '[object Map]';
|
|
}
|
|
isMapToString.working = (
|
|
typeof Map !== 'undefined' &&
|
|
isMapToString(new Map())
|
|
);
|
|
|
|
function isMap(value) {
|
|
if (typeof Map === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return isMapToString.working
|
|
? isMapToString(value)
|
|
: value instanceof Map;
|
|
}
|
|
exports.isMap = isMap;
|
|
|
|
function isSetToString(value) {
|
|
return ObjectToString(value) === '[object Set]';
|
|
}
|
|
isSetToString.working = (
|
|
typeof Set !== 'undefined' &&
|
|
isSetToString(new Set())
|
|
);
|
|
function isSet(value) {
|
|
if (typeof Set === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return isSetToString.working
|
|
? isSetToString(value)
|
|
: value instanceof Set;
|
|
}
|
|
exports.isSet = isSet;
|
|
|
|
function isWeakMapToString(value) {
|
|
return ObjectToString(value) === '[object WeakMap]';
|
|
}
|
|
isWeakMapToString.working = (
|
|
typeof WeakMap !== 'undefined' &&
|
|
isWeakMapToString(new WeakMap())
|
|
);
|
|
function isWeakMap(value) {
|
|
if (typeof WeakMap === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return isWeakMapToString.working
|
|
? isWeakMapToString(value)
|
|
: value instanceof WeakMap;
|
|
}
|
|
exports.isWeakMap = isWeakMap;
|
|
|
|
function isWeakSetToString(value) {
|
|
return ObjectToString(value) === '[object WeakSet]';
|
|
}
|
|
isWeakSetToString.working = (
|
|
typeof WeakSet !== 'undefined' &&
|
|
isWeakSetToString(new WeakSet())
|
|
);
|
|
function isWeakSet(value) {
|
|
return isWeakSetToString(value);
|
|
}
|
|
exports.isWeakSet = isWeakSet;
|
|
|
|
function isArrayBufferToString(value) {
|
|
return ObjectToString(value) === '[object ArrayBuffer]';
|
|
}
|
|
isArrayBufferToString.working = (
|
|
typeof ArrayBuffer !== 'undefined' &&
|
|
isArrayBufferToString(new ArrayBuffer())
|
|
);
|
|
function isArrayBuffer(value) {
|
|
if (typeof ArrayBuffer === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return isArrayBufferToString.working
|
|
? isArrayBufferToString(value)
|
|
: value instanceof ArrayBuffer;
|
|
}
|
|
exports.isArrayBuffer = isArrayBuffer;
|
|
|
|
function isDataViewToString(value) {
|
|
return ObjectToString(value) === '[object DataView]';
|
|
}
|
|
isDataViewToString.working = (
|
|
typeof ArrayBuffer !== 'undefined' &&
|
|
typeof DataView !== 'undefined' &&
|
|
isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1))
|
|
);
|
|
function isDataView(value) {
|
|
if (typeof DataView === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return isDataViewToString.working
|
|
? isDataViewToString(value)
|
|
: value instanceof DataView;
|
|
}
|
|
exports.isDataView = isDataView;
|
|
|
|
// Store a copy of SharedArrayBuffer in case it's deleted elsewhere
|
|
var SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined;
|
|
function isSharedArrayBufferToString(value) {
|
|
return ObjectToString(value) === '[object SharedArrayBuffer]';
|
|
}
|
|
function isSharedArrayBuffer(value) {
|
|
if (typeof SharedArrayBufferCopy === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
if (typeof isSharedArrayBufferToString.working === 'undefined') {
|
|
isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());
|
|
}
|
|
|
|
return isSharedArrayBufferToString.working
|
|
? isSharedArrayBufferToString(value)
|
|
: value instanceof SharedArrayBufferCopy;
|
|
}
|
|
exports.isSharedArrayBuffer = isSharedArrayBuffer;
|
|
|
|
function isAsyncFunction(value) {
|
|
return ObjectToString(value) === '[object AsyncFunction]';
|
|
}
|
|
exports.isAsyncFunction = isAsyncFunction;
|
|
|
|
function isMapIterator(value) {
|
|
return ObjectToString(value) === '[object Map Iterator]';
|
|
}
|
|
exports.isMapIterator = isMapIterator;
|
|
|
|
function isSetIterator(value) {
|
|
return ObjectToString(value) === '[object Set Iterator]';
|
|
}
|
|
exports.isSetIterator = isSetIterator;
|
|
|
|
function isGeneratorObject(value) {
|
|
return ObjectToString(value) === '[object Generator]';
|
|
}
|
|
exports.isGeneratorObject = isGeneratorObject;
|
|
|
|
function isWebAssemblyCompiledModule(value) {
|
|
return ObjectToString(value) === '[object WebAssembly.Module]';
|
|
}
|
|
exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;
|
|
|
|
function isNumberObject(value) {
|
|
return checkBoxedPrimitive(value, numberValue);
|
|
}
|
|
exports.isNumberObject = isNumberObject;
|
|
|
|
function isStringObject(value) {
|
|
return checkBoxedPrimitive(value, stringValue);
|
|
}
|
|
exports.isStringObject = isStringObject;
|
|
|
|
function isBooleanObject(value) {
|
|
return checkBoxedPrimitive(value, booleanValue);
|
|
}
|
|
exports.isBooleanObject = isBooleanObject;
|
|
|
|
function isBigIntObject(value) {
|
|
return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);
|
|
}
|
|
exports.isBigIntObject = isBigIntObject;
|
|
|
|
function isSymbolObject(value) {
|
|
return SymbolSupported && checkBoxedPrimitive(value, symbolValue);
|
|
}
|
|
exports.isSymbolObject = isSymbolObject;
|
|
|
|
function isBoxedPrimitive(value) {
|
|
return (
|
|
isNumberObject(value) ||
|
|
isStringObject(value) ||
|
|
isBooleanObject(value) ||
|
|
isBigIntObject(value) ||
|
|
isSymbolObject(value)
|
|
);
|
|
}
|
|
exports.isBoxedPrimitive = isBoxedPrimitive;
|
|
|
|
function isAnyArrayBuffer(value) {
|
|
return typeof Uint8Array !== 'undefined' && (
|
|
isArrayBuffer(value) ||
|
|
isSharedArrayBuffer(value)
|
|
);
|
|
}
|
|
exports.isAnyArrayBuffer = isAnyArrayBuffer;
|
|
|
|
['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) {
|
|
Object.defineProperty(exports, method, {
|
|
enumerable: false,
|
|
value: function() {
|
|
throw new Error(method + ' is not supported in userland');
|
|
}
|
|
});
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6827:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
/* provided dependency */ var process = __webpack_require__(9907);
|
|
/* provided dependency */ var console = __webpack_require__(4364);
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||
|
|
function getOwnPropertyDescriptors(obj) {
|
|
var keys = Object.keys(obj);
|
|
var descriptors = {};
|
|
for (var i = 0; i < keys.length; i++) {
|
|
descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
|
|
}
|
|
return descriptors;
|
|
};
|
|
|
|
var formatRegExp = /%[sdj%]/g;
|
|
exports.format = function(f) {
|
|
if (!isString(f)) {
|
|
var objects = [];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
objects.push(inspect(arguments[i]));
|
|
}
|
|
return objects.join(' ');
|
|
}
|
|
|
|
var i = 1;
|
|
var args = arguments;
|
|
var len = args.length;
|
|
var str = String(f).replace(formatRegExp, function(x) {
|
|
if (x === '%%') return '%';
|
|
if (i >= len) return x;
|
|
switch (x) {
|
|
case '%s': return String(args[i++]);
|
|
case '%d': return Number(args[i++]);
|
|
case '%j':
|
|
try {
|
|
return JSON.stringify(args[i++]);
|
|
} catch (_) {
|
|
return '[Circular]';
|
|
}
|
|
default:
|
|
return x;
|
|
}
|
|
});
|
|
for (var x = args[i]; i < len; x = args[++i]) {
|
|
if (isNull(x) || !isObject(x)) {
|
|
str += ' ' + x;
|
|
} else {
|
|
str += ' ' + inspect(x);
|
|
}
|
|
}
|
|
return str;
|
|
};
|
|
|
|
|
|
// Mark that a method should not be used.
|
|
// Returns a modified function which warns once by default.
|
|
// If --no-deprecation is set, then it is a no-op.
|
|
exports.deprecate = function(fn, msg) {
|
|
if (typeof process !== 'undefined' && process.noDeprecation === true) {
|
|
return fn;
|
|
}
|
|
|
|
// Allow for deprecating things in the process of starting up.
|
|
if (typeof process === 'undefined') {
|
|
return function() {
|
|
return exports.deprecate(fn, msg).apply(this, arguments);
|
|
};
|
|
}
|
|
|
|
var warned = false;
|
|
function deprecated() {
|
|
if (!warned) {
|
|
if (process.throwDeprecation) {
|
|
throw new Error(msg);
|
|
} else if (process.traceDeprecation) {
|
|
console.trace(msg);
|
|
} else {
|
|
console.error(msg);
|
|
}
|
|
warned = true;
|
|
}
|
|
return fn.apply(this, arguments);
|
|
}
|
|
|
|
return deprecated;
|
|
};
|
|
|
|
|
|
var debugs = {};
|
|
var debugEnvRegex = /^$/;
|
|
|
|
if (process.env.NODE_DEBUG) {
|
|
var debugEnv = process.env.NODE_DEBUG;
|
|
debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, '\\$&')
|
|
.replace(/\*/g, '.*')
|
|
.replace(/,/g, '$|^')
|
|
.toUpperCase();
|
|
debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i');
|
|
}
|
|
exports.debuglog = function(set) {
|
|
set = set.toUpperCase();
|
|
if (!debugs[set]) {
|
|
if (debugEnvRegex.test(set)) {
|
|
var pid = process.pid;
|
|
debugs[set] = function() {
|
|
var msg = exports.format.apply(exports, arguments);
|
|
console.error('%s %d: %s', set, pid, msg);
|
|
};
|
|
} else {
|
|
debugs[set] = function() {};
|
|
}
|
|
}
|
|
return debugs[set];
|
|
};
|
|
|
|
|
|
/**
|
|
* Echos the value of a value. Trys to print the value out
|
|
* in the best way possible given the different types.
|
|
*
|
|
* @param {Object} obj The object to print out.
|
|
* @param {Object} opts Optional options object that alters the output.
|
|
*/
|
|
/* legacy: obj, showHidden, depth, colors*/
|
|
function inspect(obj, opts) {
|
|
// default options
|
|
var ctx = {
|
|
seen: [],
|
|
stylize: stylizeNoColor
|
|
};
|
|
// legacy...
|
|
if (arguments.length >= 3) ctx.depth = arguments[2];
|
|
if (arguments.length >= 4) ctx.colors = arguments[3];
|
|
if (isBoolean(opts)) {
|
|
// legacy...
|
|
ctx.showHidden = opts;
|
|
} else if (opts) {
|
|
// got an "options" object
|
|
exports._extend(ctx, opts);
|
|
}
|
|
// set default options
|
|
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
|
|
if (isUndefined(ctx.depth)) ctx.depth = 2;
|
|
if (isUndefined(ctx.colors)) ctx.colors = false;
|
|
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
|
|
if (ctx.colors) ctx.stylize = stylizeWithColor;
|
|
return formatValue(ctx, obj, ctx.depth);
|
|
}
|
|
exports.inspect = inspect;
|
|
|
|
|
|
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
|
|
inspect.colors = {
|
|
'bold' : [1, 22],
|
|
'italic' : [3, 23],
|
|
'underline' : [4, 24],
|
|
'inverse' : [7, 27],
|
|
'white' : [37, 39],
|
|
'grey' : [90, 39],
|
|
'black' : [30, 39],
|
|
'blue' : [34, 39],
|
|
'cyan' : [36, 39],
|
|
'green' : [32, 39],
|
|
'magenta' : [35, 39],
|
|
'red' : [31, 39],
|
|
'yellow' : [33, 39]
|
|
};
|
|
|
|
// Don't use 'blue' not visible on cmd.exe
|
|
inspect.styles = {
|
|
'special': 'cyan',
|
|
'number': 'yellow',
|
|
'boolean': 'yellow',
|
|
'undefined': 'grey',
|
|
'null': 'bold',
|
|
'string': 'green',
|
|
'date': 'magenta',
|
|
// "name": intentionally not styling
|
|
'regexp': 'red'
|
|
};
|
|
|
|
|
|
function stylizeWithColor(str, styleType) {
|
|
var style = inspect.styles[styleType];
|
|
|
|
if (style) {
|
|
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
|
|
'\u001b[' + inspect.colors[style][1] + 'm';
|
|
} else {
|
|
return str;
|
|
}
|
|
}
|
|
|
|
|
|
function stylizeNoColor(str, styleType) {
|
|
return str;
|
|
}
|
|
|
|
|
|
function arrayToHash(array) {
|
|
var hash = {};
|
|
|
|
array.forEach(function(val, idx) {
|
|
hash[val] = true;
|
|
});
|
|
|
|
return hash;
|
|
}
|
|
|
|
|
|
function formatValue(ctx, value, recurseTimes) {
|
|
// Provide a hook for user-specified inspect functions.
|
|
// Check that value is an object with an inspect function on it
|
|
if (ctx.customInspect &&
|
|
value &&
|
|
isFunction(value.inspect) &&
|
|
// Filter out the util module, it's inspect function is special
|
|
value.inspect !== exports.inspect &&
|
|
// Also filter out any prototype objects using the circular check.
|
|
!(value.constructor && value.constructor.prototype === value)) {
|
|
var ret = value.inspect(recurseTimes, ctx);
|
|
if (!isString(ret)) {
|
|
ret = formatValue(ctx, ret, recurseTimes);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// Primitive types cannot have properties
|
|
var primitive = formatPrimitive(ctx, value);
|
|
if (primitive) {
|
|
return primitive;
|
|
}
|
|
|
|
// Look up the keys of the object.
|
|
var keys = Object.keys(value);
|
|
var visibleKeys = arrayToHash(keys);
|
|
|
|
if (ctx.showHidden) {
|
|
keys = Object.getOwnPropertyNames(value);
|
|
}
|
|
|
|
// IE doesn't make error fields non-enumerable
|
|
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
|
|
if (isError(value)
|
|
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
|
|
return formatError(value);
|
|
}
|
|
|
|
// Some type of object without properties can be shortcutted.
|
|
if (keys.length === 0) {
|
|
if (isFunction(value)) {
|
|
var name = value.name ? ': ' + value.name : '';
|
|
return ctx.stylize('[Function' + name + ']', 'special');
|
|
}
|
|
if (isRegExp(value)) {
|
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
}
|
|
if (isDate(value)) {
|
|
return ctx.stylize(Date.prototype.toString.call(value), 'date');
|
|
}
|
|
if (isError(value)) {
|
|
return formatError(value);
|
|
}
|
|
}
|
|
|
|
var base = '', array = false, braces = ['{', '}'];
|
|
|
|
// Make Array say that they are Array
|
|
if (isArray(value)) {
|
|
array = true;
|
|
braces = ['[', ']'];
|
|
}
|
|
|
|
// Make functions say that they are functions
|
|
if (isFunction(value)) {
|
|
var n = value.name ? ': ' + value.name : '';
|
|
base = ' [Function' + n + ']';
|
|
}
|
|
|
|
// Make RegExps say that they are RegExps
|
|
if (isRegExp(value)) {
|
|
base = ' ' + RegExp.prototype.toString.call(value);
|
|
}
|
|
|
|
// Make dates with properties first say the date
|
|
if (isDate(value)) {
|
|
base = ' ' + Date.prototype.toUTCString.call(value);
|
|
}
|
|
|
|
// Make error with message first say the error
|
|
if (isError(value)) {
|
|
base = ' ' + formatError(value);
|
|
}
|
|
|
|
if (keys.length === 0 && (!array || value.length == 0)) {
|
|
return braces[0] + base + braces[1];
|
|
}
|
|
|
|
if (recurseTimes < 0) {
|
|
if (isRegExp(value)) {
|
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
} else {
|
|
return ctx.stylize('[Object]', 'special');
|
|
}
|
|
}
|
|
|
|
ctx.seen.push(value);
|
|
|
|
var output;
|
|
if (array) {
|
|
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
|
|
} else {
|
|
output = keys.map(function(key) {
|
|
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
|
|
});
|
|
}
|
|
|
|
ctx.seen.pop();
|
|
|
|
return reduceToSingleString(output, base, braces);
|
|
}
|
|
|
|
|
|
function formatPrimitive(ctx, value) {
|
|
if (isUndefined(value))
|
|
return ctx.stylize('undefined', 'undefined');
|
|
if (isString(value)) {
|
|
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
|
|
.replace(/'/g, "\\'")
|
|
.replace(/\\"/g, '"') + '\'';
|
|
return ctx.stylize(simple, 'string');
|
|
}
|
|
if (isNumber(value))
|
|
return ctx.stylize('' + value, 'number');
|
|
if (isBoolean(value))
|
|
return ctx.stylize('' + value, 'boolean');
|
|
// For some reason typeof null is "object", so special case here.
|
|
if (isNull(value))
|
|
return ctx.stylize('null', 'null');
|
|
}
|
|
|
|
|
|
function formatError(value) {
|
|
return '[' + Error.prototype.toString.call(value) + ']';
|
|
}
|
|
|
|
|
|
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
|
|
var output = [];
|
|
for (var i = 0, l = value.length; i < l; ++i) {
|
|
if (hasOwnProperty(value, String(i))) {
|
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
String(i), true));
|
|
} else {
|
|
output.push('');
|
|
}
|
|
}
|
|
keys.forEach(function(key) {
|
|
if (!key.match(/^\d+$/)) {
|
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
key, true));
|
|
}
|
|
});
|
|
return output;
|
|
}
|
|
|
|
|
|
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
|
|
var name, str, desc;
|
|
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
|
|
if (desc.get) {
|
|
if (desc.set) {
|
|
str = ctx.stylize('[Getter/Setter]', 'special');
|
|
} else {
|
|
str = ctx.stylize('[Getter]', 'special');
|
|
}
|
|
} else {
|
|
if (desc.set) {
|
|
str = ctx.stylize('[Setter]', 'special');
|
|
}
|
|
}
|
|
if (!hasOwnProperty(visibleKeys, key)) {
|
|
name = '[' + key + ']';
|
|
}
|
|
if (!str) {
|
|
if (ctx.seen.indexOf(desc.value) < 0) {
|
|
if (isNull(recurseTimes)) {
|
|
str = formatValue(ctx, desc.value, null);
|
|
} else {
|
|
str = formatValue(ctx, desc.value, recurseTimes - 1);
|
|
}
|
|
if (str.indexOf('\n') > -1) {
|
|
if (array) {
|
|
str = str.split('\n').map(function(line) {
|
|
return ' ' + line;
|
|
}).join('\n').slice(2);
|
|
} else {
|
|
str = '\n' + str.split('\n').map(function(line) {
|
|
return ' ' + line;
|
|
}).join('\n');
|
|
}
|
|
}
|
|
} else {
|
|
str = ctx.stylize('[Circular]', 'special');
|
|
}
|
|
}
|
|
if (isUndefined(name)) {
|
|
if (array && key.match(/^\d+$/)) {
|
|
return str;
|
|
}
|
|
name = JSON.stringify('' + key);
|
|
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
|
|
name = name.slice(1, -1);
|
|
name = ctx.stylize(name, 'name');
|
|
} else {
|
|
name = name.replace(/'/g, "\\'")
|
|
.replace(/\\"/g, '"')
|
|
.replace(/(^"|"$)/g, "'");
|
|
name = ctx.stylize(name, 'string');
|
|
}
|
|
}
|
|
|
|
return name + ': ' + str;
|
|
}
|
|
|
|
|
|
function reduceToSingleString(output, base, braces) {
|
|
var numLinesEst = 0;
|
|
var length = output.reduce(function(prev, cur) {
|
|
numLinesEst++;
|
|
if (cur.indexOf('\n') >= 0) numLinesEst++;
|
|
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
|
|
}, 0);
|
|
|
|
if (length > 60) {
|
|
return braces[0] +
|
|
(base === '' ? '' : base + '\n ') +
|
|
' ' +
|
|
output.join(',\n ') +
|
|
' ' +
|
|
braces[1];
|
|
}
|
|
|
|
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
|
|
}
|
|
|
|
|
|
// NOTE: These type checking functions intentionally don't use `instanceof`
|
|
// because it is fragile and can be easily faked with `Object.create()`.
|
|
exports.types = __webpack_require__(1531);
|
|
|
|
function isArray(ar) {
|
|
return Array.isArray(ar);
|
|
}
|
|
exports.isArray = isArray;
|
|
|
|
function isBoolean(arg) {
|
|
return typeof arg === 'boolean';
|
|
}
|
|
exports.isBoolean = isBoolean;
|
|
|
|
function isNull(arg) {
|
|
return arg === null;
|
|
}
|
|
exports.isNull = isNull;
|
|
|
|
function isNullOrUndefined(arg) {
|
|
return arg == null;
|
|
}
|
|
exports.isNullOrUndefined = isNullOrUndefined;
|
|
|
|
function isNumber(arg) {
|
|
return typeof arg === 'number';
|
|
}
|
|
exports.isNumber = isNumber;
|
|
|
|
function isString(arg) {
|
|
return typeof arg === 'string';
|
|
}
|
|
exports.isString = isString;
|
|
|
|
function isSymbol(arg) {
|
|
return typeof arg === 'symbol';
|
|
}
|
|
exports.isSymbol = isSymbol;
|
|
|
|
function isUndefined(arg) {
|
|
return arg === void 0;
|
|
}
|
|
exports.isUndefined = isUndefined;
|
|
|
|
function isRegExp(re) {
|
|
return isObject(re) && objectToString(re) === '[object RegExp]';
|
|
}
|
|
exports.isRegExp = isRegExp;
|
|
exports.types.isRegExp = isRegExp;
|
|
|
|
function isObject(arg) {
|
|
return typeof arg === 'object' && arg !== null;
|
|
}
|
|
exports.isObject = isObject;
|
|
|
|
function isDate(d) {
|
|
return isObject(d) && objectToString(d) === '[object Date]';
|
|
}
|
|
exports.isDate = isDate;
|
|
exports.types.isDate = isDate;
|
|
|
|
function isError(e) {
|
|
return isObject(e) &&
|
|
(objectToString(e) === '[object Error]' || e instanceof Error);
|
|
}
|
|
exports.isError = isError;
|
|
exports.types.isNativeError = isError;
|
|
|
|
function isFunction(arg) {
|
|
return typeof arg === 'function';
|
|
}
|
|
exports.isFunction = isFunction;
|
|
|
|
function isPrimitive(arg) {
|
|
return arg === null ||
|
|
typeof arg === 'boolean' ||
|
|
typeof arg === 'number' ||
|
|
typeof arg === 'string' ||
|
|
typeof arg === 'symbol' || // ES6 symbol
|
|
typeof arg === 'undefined';
|
|
}
|
|
exports.isPrimitive = isPrimitive;
|
|
|
|
exports.isBuffer = __webpack_require__(5272);
|
|
|
|
function objectToString(o) {
|
|
return Object.prototype.toString.call(o);
|
|
}
|
|
|
|
|
|
function pad(n) {
|
|
return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
|
}
|
|
|
|
|
|
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
|
|
'Oct', 'Nov', 'Dec'];
|
|
|
|
// 26 Feb 16:19:34
|
|
function timestamp() {
|
|
var d = new Date();
|
|
var time = [pad(d.getHours()),
|
|
pad(d.getMinutes()),
|
|
pad(d.getSeconds())].join(':');
|
|
return [d.getDate(), months[d.getMonth()], time].join(' ');
|
|
}
|
|
|
|
|
|
// log is just a thin wrapper to console.log that prepends a timestamp
|
|
exports.log = function() {
|
|
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
|
|
};
|
|
|
|
|
|
/**
|
|
* Inherit the prototype methods from one constructor into another.
|
|
*
|
|
* The Function.prototype.inherits from lang.js rewritten as a standalone
|
|
* function (not on Function.prototype). NOTE: If this file is to be loaded
|
|
* during bootstrapping this function needs to be rewritten using some native
|
|
* functions as prototype setup using normal JavaScript does not work as
|
|
* expected during bootstrapping (see mirror.js in r114903).
|
|
*
|
|
* @param {function} ctor Constructor function which needs to inherit the
|
|
* prototype.
|
|
* @param {function} superCtor Constructor function to inherit prototype from.
|
|
*/
|
|
exports.inherits = __webpack_require__(5615);
|
|
|
|
exports._extend = function(origin, add) {
|
|
// Don't do anything if add isn't an object
|
|
if (!add || !isObject(add)) return origin;
|
|
|
|
var keys = Object.keys(add);
|
|
var i = keys.length;
|
|
while (i--) {
|
|
origin[keys[i]] = add[keys[i]];
|
|
}
|
|
return origin;
|
|
};
|
|
|
|
function hasOwnProperty(obj, prop) {
|
|
return Object.prototype.hasOwnProperty.call(obj, prop);
|
|
}
|
|
|
|
var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;
|
|
|
|
exports.promisify = function promisify(original) {
|
|
if (typeof original !== 'function')
|
|
throw new TypeError('The "original" argument must be of type Function');
|
|
|
|
if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
|
|
var fn = original[kCustomPromisifiedSymbol];
|
|
if (typeof fn !== 'function') {
|
|
throw new TypeError('The "util.promisify.custom" argument must be of type Function');
|
|
}
|
|
Object.defineProperty(fn, kCustomPromisifiedSymbol, {
|
|
value: fn, enumerable: false, writable: false, configurable: true
|
|
});
|
|
return fn;
|
|
}
|
|
|
|
function fn() {
|
|
var promiseResolve, promiseReject;
|
|
var promise = new Promise(function (resolve, reject) {
|
|
promiseResolve = resolve;
|
|
promiseReject = reject;
|
|
});
|
|
|
|
var args = [];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
args.push(arguments[i]);
|
|
}
|
|
args.push(function (err, value) {
|
|
if (err) {
|
|
promiseReject(err);
|
|
} else {
|
|
promiseResolve(value);
|
|
}
|
|
});
|
|
|
|
try {
|
|
original.apply(this, args);
|
|
} catch (err) {
|
|
promiseReject(err);
|
|
}
|
|
|
|
return promise;
|
|
}
|
|
|
|
Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
|
|
|
|
if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
|
|
value: fn, enumerable: false, writable: false, configurable: true
|
|
});
|
|
return Object.defineProperties(
|
|
fn,
|
|
getOwnPropertyDescriptors(original)
|
|
);
|
|
}
|
|
|
|
exports.promisify.custom = kCustomPromisifiedSymbol
|
|
|
|
function callbackifyOnRejected(reason, cb) {
|
|
// `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
|
|
// Because `null` is a special error value in callbacks which means "no error
|
|
// occurred", we error-wrap so the callback consumer can distinguish between
|
|
// "the promise rejected with null" or "the promise fulfilled with undefined".
|
|
if (!reason) {
|
|
var newReason = new Error('Promise was rejected with a falsy value');
|
|
newReason.reason = reason;
|
|
reason = newReason;
|
|
}
|
|
return cb(reason);
|
|
}
|
|
|
|
function callbackify(original) {
|
|
if (typeof original !== 'function') {
|
|
throw new TypeError('The "original" argument must be of type Function');
|
|
}
|
|
|
|
// We DO NOT return the promise as it gives the user a false sense that
|
|
// the promise is actually somehow related to the callback's execution
|
|
// and that the callback throwing will reject the promise.
|
|
function callbackified() {
|
|
var args = [];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
args.push(arguments[i]);
|
|
}
|
|
|
|
var maybeCb = args.pop();
|
|
if (typeof maybeCb !== 'function') {
|
|
throw new TypeError('The last argument must be of type Function');
|
|
}
|
|
var self = this;
|
|
var cb = function() {
|
|
return maybeCb.apply(self, arguments);
|
|
};
|
|
// In true node style we process the callback on `nextTick` with all the
|
|
// implications (stack, `uncaughtException`, `async_hooks`)
|
|
original.apply(this, args)
|
|
.then(function(ret) { process.nextTick(cb.bind(null, null, ret)) },
|
|
function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) });
|
|
}
|
|
|
|
Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
|
|
Object.defineProperties(callbackified,
|
|
getOwnPropertyDescriptors(original));
|
|
return callbackified;
|
|
}
|
|
exports.callbackify = callbackify;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9208:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ----------------------------------------------------------------------------------------- */
|
|
|
|
|
|
module.exports = __webpack_require__(9110);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9110:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
|
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.createMessageConnection = exports.BrowserMessageWriter = exports.BrowserMessageReader = void 0;
|
|
const ril_1 = __webpack_require__(3312);
|
|
// Install the browser runtime abstract.
|
|
ril_1.default.install();
|
|
const api_1 = __webpack_require__(7672);
|
|
__exportStar(__webpack_require__(7672), exports);
|
|
class BrowserMessageReader extends api_1.AbstractMessageReader {
|
|
constructor(port) {
|
|
super();
|
|
this._onData = new api_1.Emitter();
|
|
this._messageListener = (event) => {
|
|
this._onData.fire(event.data);
|
|
};
|
|
port.addEventListener('error', (event) => this.fireError(event));
|
|
port.onmessage = this._messageListener;
|
|
}
|
|
listen(callback) {
|
|
return this._onData.event(callback);
|
|
}
|
|
}
|
|
exports.BrowserMessageReader = BrowserMessageReader;
|
|
class BrowserMessageWriter extends api_1.AbstractMessageWriter {
|
|
constructor(port) {
|
|
super();
|
|
this.port = port;
|
|
this.errorCount = 0;
|
|
port.addEventListener('error', (event) => this.fireError(event));
|
|
}
|
|
write(msg) {
|
|
try {
|
|
this.port.postMessage(msg);
|
|
return Promise.resolve();
|
|
}
|
|
catch (error) {
|
|
this.handleError(error, msg);
|
|
return Promise.reject(error);
|
|
}
|
|
}
|
|
handleError(error, msg) {
|
|
this.errorCount++;
|
|
this.fireError(error, msg, this.errorCount);
|
|
}
|
|
end() {
|
|
}
|
|
}
|
|
exports.BrowserMessageWriter = BrowserMessageWriter;
|
|
function createMessageConnection(reader, writer, logger, options) {
|
|
if (logger === undefined) {
|
|
logger = api_1.NullLogger;
|
|
}
|
|
if (api_1.ConnectionStrategy.is(options)) {
|
|
options = { connectionStrategy: options };
|
|
}
|
|
return (0, api_1.createMessageConnection)(reader, writer, logger, options);
|
|
}
|
|
exports.createMessageConnection = createMessageConnection;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3312:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
/* provided dependency */ var console = __webpack_require__(4364);
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
const api_1 = __webpack_require__(7672);
|
|
class MessageBuffer extends api_1.AbstractMessageBuffer {
|
|
constructor(encoding = 'utf-8') {
|
|
super(encoding);
|
|
this.asciiDecoder = new TextDecoder('ascii');
|
|
}
|
|
emptyBuffer() {
|
|
return MessageBuffer.emptyBuffer;
|
|
}
|
|
fromString(value, _encoding) {
|
|
return (new TextEncoder()).encode(value);
|
|
}
|
|
toString(value, encoding) {
|
|
if (encoding === 'ascii') {
|
|
return this.asciiDecoder.decode(value);
|
|
}
|
|
else {
|
|
return (new TextDecoder(encoding)).decode(value);
|
|
}
|
|
}
|
|
asNative(buffer, length) {
|
|
if (length === undefined) {
|
|
return buffer;
|
|
}
|
|
else {
|
|
return buffer.slice(0, length);
|
|
}
|
|
}
|
|
allocNative(length) {
|
|
return new Uint8Array(length);
|
|
}
|
|
}
|
|
MessageBuffer.emptyBuffer = new Uint8Array(0);
|
|
class ReadableStreamWrapper {
|
|
constructor(socket) {
|
|
this.socket = socket;
|
|
this._onData = new api_1.Emitter();
|
|
this._messageListener = (event) => {
|
|
const blob = event.data;
|
|
blob.arrayBuffer().then((buffer) => {
|
|
this._onData.fire(new Uint8Array(buffer));
|
|
}, () => {
|
|
(0, api_1.RAL)().console.error(`Converting blob to array buffer failed.`);
|
|
});
|
|
};
|
|
this.socket.addEventListener('message', this._messageListener);
|
|
}
|
|
onClose(listener) {
|
|
this.socket.addEventListener('close', listener);
|
|
return api_1.Disposable.create(() => this.socket.removeEventListener('close', listener));
|
|
}
|
|
onError(listener) {
|
|
this.socket.addEventListener('error', listener);
|
|
return api_1.Disposable.create(() => this.socket.removeEventListener('error', listener));
|
|
}
|
|
onEnd(listener) {
|
|
this.socket.addEventListener('end', listener);
|
|
return api_1.Disposable.create(() => this.socket.removeEventListener('end', listener));
|
|
}
|
|
onData(listener) {
|
|
return this._onData.event(listener);
|
|
}
|
|
}
|
|
class WritableStreamWrapper {
|
|
constructor(socket) {
|
|
this.socket = socket;
|
|
}
|
|
onClose(listener) {
|
|
this.socket.addEventListener('close', listener);
|
|
return api_1.Disposable.create(() => this.socket.removeEventListener('close', listener));
|
|
}
|
|
onError(listener) {
|
|
this.socket.addEventListener('error', listener);
|
|
return api_1.Disposable.create(() => this.socket.removeEventListener('error', listener));
|
|
}
|
|
onEnd(listener) {
|
|
this.socket.addEventListener('end', listener);
|
|
return api_1.Disposable.create(() => this.socket.removeEventListener('end', listener));
|
|
}
|
|
write(data, encoding) {
|
|
if (typeof data === 'string') {
|
|
if (encoding !== undefined && encoding !== 'utf-8') {
|
|
throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${encoding}`);
|
|
}
|
|
this.socket.send(data);
|
|
}
|
|
else {
|
|
this.socket.send(data);
|
|
}
|
|
return Promise.resolve();
|
|
}
|
|
end() {
|
|
this.socket.close();
|
|
}
|
|
}
|
|
const _textEncoder = new TextEncoder();
|
|
const _ril = Object.freeze({
|
|
messageBuffer: Object.freeze({
|
|
create: (encoding) => new MessageBuffer(encoding)
|
|
}),
|
|
applicationJson: Object.freeze({
|
|
encoder: Object.freeze({
|
|
name: 'application/json',
|
|
encode: (msg, options) => {
|
|
if (options.charset !== 'utf-8') {
|
|
throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${options.charset}`);
|
|
}
|
|
return Promise.resolve(_textEncoder.encode(JSON.stringify(msg, undefined, 0)));
|
|
}
|
|
}),
|
|
decoder: Object.freeze({
|
|
name: 'application/json',
|
|
decode: (buffer, options) => {
|
|
if (!(buffer instanceof Uint8Array)) {
|
|
throw new Error(`In a Browser environments only Uint8Arrays are supported.`);
|
|
}
|
|
return Promise.resolve(JSON.parse(new TextDecoder(options.charset).decode(buffer)));
|
|
}
|
|
})
|
|
}),
|
|
stream: Object.freeze({
|
|
asReadableStream: (socket) => new ReadableStreamWrapper(socket),
|
|
asWritableStream: (socket) => new WritableStreamWrapper(socket)
|
|
}),
|
|
console: console,
|
|
timer: Object.freeze({
|
|
setTimeout(callback, ms, ...args) {
|
|
const handle = setTimeout(callback, ms, ...args);
|
|
return { dispose: () => clearTimeout(handle) };
|
|
},
|
|
setImmediate(callback, ...args) {
|
|
const handle = setTimeout(callback, 0, ...args);
|
|
return { dispose: () => clearTimeout(handle) };
|
|
},
|
|
setInterval(callback, ms, ...args) {
|
|
const handle = setInterval(callback, ms, ...args);
|
|
return { dispose: () => clearInterval(handle) };
|
|
},
|
|
})
|
|
});
|
|
function RIL() {
|
|
return _ril;
|
|
}
|
|
(function (RIL) {
|
|
function install() {
|
|
api_1.RAL.install(_ril);
|
|
}
|
|
RIL.install = install;
|
|
})(RIL || (RIL = {}));
|
|
exports["default"] = RIL;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7672:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
/// <reference path="../../typings/thenable.d.ts" />
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.ProgressType = exports.ProgressToken = exports.createMessageConnection = exports.NullLogger = exports.ConnectionOptions = exports.ConnectionStrategy = exports.AbstractMessageBuffer = exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = exports.CancellationToken = exports.CancellationTokenSource = exports.Emitter = exports.Event = exports.Disposable = exports.LRUCache = exports.Touch = exports.LinkedMap = exports.ParameterStructures = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.ErrorCodes = exports.ResponseError = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType0 = exports.RequestType = exports.Message = exports.RAL = void 0;
|
|
exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.Trace = void 0;
|
|
const messages_1 = __webpack_require__(7162);
|
|
Object.defineProperty(exports, "Message", ({ enumerable: true, get: function () { return messages_1.Message; } }));
|
|
Object.defineProperty(exports, "RequestType", ({ enumerable: true, get: function () { return messages_1.RequestType; } }));
|
|
Object.defineProperty(exports, "RequestType0", ({ enumerable: true, get: function () { return messages_1.RequestType0; } }));
|
|
Object.defineProperty(exports, "RequestType1", ({ enumerable: true, get: function () { return messages_1.RequestType1; } }));
|
|
Object.defineProperty(exports, "RequestType2", ({ enumerable: true, get: function () { return messages_1.RequestType2; } }));
|
|
Object.defineProperty(exports, "RequestType3", ({ enumerable: true, get: function () { return messages_1.RequestType3; } }));
|
|
Object.defineProperty(exports, "RequestType4", ({ enumerable: true, get: function () { return messages_1.RequestType4; } }));
|
|
Object.defineProperty(exports, "RequestType5", ({ enumerable: true, get: function () { return messages_1.RequestType5; } }));
|
|
Object.defineProperty(exports, "RequestType6", ({ enumerable: true, get: function () { return messages_1.RequestType6; } }));
|
|
Object.defineProperty(exports, "RequestType7", ({ enumerable: true, get: function () { return messages_1.RequestType7; } }));
|
|
Object.defineProperty(exports, "RequestType8", ({ enumerable: true, get: function () { return messages_1.RequestType8; } }));
|
|
Object.defineProperty(exports, "RequestType9", ({ enumerable: true, get: function () { return messages_1.RequestType9; } }));
|
|
Object.defineProperty(exports, "ResponseError", ({ enumerable: true, get: function () { return messages_1.ResponseError; } }));
|
|
Object.defineProperty(exports, "ErrorCodes", ({ enumerable: true, get: function () { return messages_1.ErrorCodes; } }));
|
|
Object.defineProperty(exports, "NotificationType", ({ enumerable: true, get: function () { return messages_1.NotificationType; } }));
|
|
Object.defineProperty(exports, "NotificationType0", ({ enumerable: true, get: function () { return messages_1.NotificationType0; } }));
|
|
Object.defineProperty(exports, "NotificationType1", ({ enumerable: true, get: function () { return messages_1.NotificationType1; } }));
|
|
Object.defineProperty(exports, "NotificationType2", ({ enumerable: true, get: function () { return messages_1.NotificationType2; } }));
|
|
Object.defineProperty(exports, "NotificationType3", ({ enumerable: true, get: function () { return messages_1.NotificationType3; } }));
|
|
Object.defineProperty(exports, "NotificationType4", ({ enumerable: true, get: function () { return messages_1.NotificationType4; } }));
|
|
Object.defineProperty(exports, "NotificationType5", ({ enumerable: true, get: function () { return messages_1.NotificationType5; } }));
|
|
Object.defineProperty(exports, "NotificationType6", ({ enumerable: true, get: function () { return messages_1.NotificationType6; } }));
|
|
Object.defineProperty(exports, "NotificationType7", ({ enumerable: true, get: function () { return messages_1.NotificationType7; } }));
|
|
Object.defineProperty(exports, "NotificationType8", ({ enumerable: true, get: function () { return messages_1.NotificationType8; } }));
|
|
Object.defineProperty(exports, "NotificationType9", ({ enumerable: true, get: function () { return messages_1.NotificationType9; } }));
|
|
Object.defineProperty(exports, "ParameterStructures", ({ enumerable: true, get: function () { return messages_1.ParameterStructures; } }));
|
|
const linkedMap_1 = __webpack_require__(1109);
|
|
Object.defineProperty(exports, "LinkedMap", ({ enumerable: true, get: function () { return linkedMap_1.LinkedMap; } }));
|
|
Object.defineProperty(exports, "LRUCache", ({ enumerable: true, get: function () { return linkedMap_1.LRUCache; } }));
|
|
Object.defineProperty(exports, "Touch", ({ enumerable: true, get: function () { return linkedMap_1.Touch; } }));
|
|
const disposable_1 = __webpack_require__(8844);
|
|
Object.defineProperty(exports, "Disposable", ({ enumerable: true, get: function () { return disposable_1.Disposable; } }));
|
|
const events_1 = __webpack_require__(2479);
|
|
Object.defineProperty(exports, "Event", ({ enumerable: true, get: function () { return events_1.Event; } }));
|
|
Object.defineProperty(exports, "Emitter", ({ enumerable: true, get: function () { return events_1.Emitter; } }));
|
|
const cancellation_1 = __webpack_require__(6957);
|
|
Object.defineProperty(exports, "CancellationTokenSource", ({ enumerable: true, get: function () { return cancellation_1.CancellationTokenSource; } }));
|
|
Object.defineProperty(exports, "CancellationToken", ({ enumerable: true, get: function () { return cancellation_1.CancellationToken; } }));
|
|
const sharedArrayCancellation_1 = __webpack_require__(3489);
|
|
Object.defineProperty(exports, "SharedArraySenderStrategy", ({ enumerable: true, get: function () { return sharedArrayCancellation_1.SharedArraySenderStrategy; } }));
|
|
Object.defineProperty(exports, "SharedArrayReceiverStrategy", ({ enumerable: true, get: function () { return sharedArrayCancellation_1.SharedArrayReceiverStrategy; } }));
|
|
const messageReader_1 = __webpack_require__(656);
|
|
Object.defineProperty(exports, "MessageReader", ({ enumerable: true, get: function () { return messageReader_1.MessageReader; } }));
|
|
Object.defineProperty(exports, "AbstractMessageReader", ({ enumerable: true, get: function () { return messageReader_1.AbstractMessageReader; } }));
|
|
Object.defineProperty(exports, "ReadableStreamMessageReader", ({ enumerable: true, get: function () { return messageReader_1.ReadableStreamMessageReader; } }));
|
|
const messageWriter_1 = __webpack_require__(9036);
|
|
Object.defineProperty(exports, "MessageWriter", ({ enumerable: true, get: function () { return messageWriter_1.MessageWriter; } }));
|
|
Object.defineProperty(exports, "AbstractMessageWriter", ({ enumerable: true, get: function () { return messageWriter_1.AbstractMessageWriter; } }));
|
|
Object.defineProperty(exports, "WriteableStreamMessageWriter", ({ enumerable: true, get: function () { return messageWriter_1.WriteableStreamMessageWriter; } }));
|
|
const messageBuffer_1 = __webpack_require__(9805);
|
|
Object.defineProperty(exports, "AbstractMessageBuffer", ({ enumerable: true, get: function () { return messageBuffer_1.AbstractMessageBuffer; } }));
|
|
const connection_1 = __webpack_require__(4054);
|
|
Object.defineProperty(exports, "ConnectionStrategy", ({ enumerable: true, get: function () { return connection_1.ConnectionStrategy; } }));
|
|
Object.defineProperty(exports, "ConnectionOptions", ({ enumerable: true, get: function () { return connection_1.ConnectionOptions; } }));
|
|
Object.defineProperty(exports, "NullLogger", ({ enumerable: true, get: function () { return connection_1.NullLogger; } }));
|
|
Object.defineProperty(exports, "createMessageConnection", ({ enumerable: true, get: function () { return connection_1.createMessageConnection; } }));
|
|
Object.defineProperty(exports, "ProgressToken", ({ enumerable: true, get: function () { return connection_1.ProgressToken; } }));
|
|
Object.defineProperty(exports, "ProgressType", ({ enumerable: true, get: function () { return connection_1.ProgressType; } }));
|
|
Object.defineProperty(exports, "Trace", ({ enumerable: true, get: function () { return connection_1.Trace; } }));
|
|
Object.defineProperty(exports, "TraceValues", ({ enumerable: true, get: function () { return connection_1.TraceValues; } }));
|
|
Object.defineProperty(exports, "TraceFormat", ({ enumerable: true, get: function () { return connection_1.TraceFormat; } }));
|
|
Object.defineProperty(exports, "SetTraceNotification", ({ enumerable: true, get: function () { return connection_1.SetTraceNotification; } }));
|
|
Object.defineProperty(exports, "LogTraceNotification", ({ enumerable: true, get: function () { return connection_1.LogTraceNotification; } }));
|
|
Object.defineProperty(exports, "ConnectionErrors", ({ enumerable: true, get: function () { return connection_1.ConnectionErrors; } }));
|
|
Object.defineProperty(exports, "ConnectionError", ({ enumerable: true, get: function () { return connection_1.ConnectionError; } }));
|
|
Object.defineProperty(exports, "CancellationReceiverStrategy", ({ enumerable: true, get: function () { return connection_1.CancellationReceiverStrategy; } }));
|
|
Object.defineProperty(exports, "CancellationSenderStrategy", ({ enumerable: true, get: function () { return connection_1.CancellationSenderStrategy; } }));
|
|
Object.defineProperty(exports, "CancellationStrategy", ({ enumerable: true, get: function () { return connection_1.CancellationStrategy; } }));
|
|
Object.defineProperty(exports, "MessageStrategy", ({ enumerable: true, get: function () { return connection_1.MessageStrategy; } }));
|
|
const ral_1 = __webpack_require__(5091);
|
|
exports.RAL = ral_1.default;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6957:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.CancellationTokenSource = exports.CancellationToken = void 0;
|
|
const ral_1 = __webpack_require__(5091);
|
|
const Is = __webpack_require__(6618);
|
|
const events_1 = __webpack_require__(2479);
|
|
var CancellationToken;
|
|
(function (CancellationToken) {
|
|
CancellationToken.None = Object.freeze({
|
|
isCancellationRequested: false,
|
|
onCancellationRequested: events_1.Event.None
|
|
});
|
|
CancellationToken.Cancelled = Object.freeze({
|
|
isCancellationRequested: true,
|
|
onCancellationRequested: events_1.Event.None
|
|
});
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && (candidate === CancellationToken.None
|
|
|| candidate === CancellationToken.Cancelled
|
|
|| (Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested));
|
|
}
|
|
CancellationToken.is = is;
|
|
})(CancellationToken = exports.CancellationToken || (exports.CancellationToken = {}));
|
|
const shortcutEvent = Object.freeze(function (callback, context) {
|
|
const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);
|
|
return { dispose() { handle.dispose(); } };
|
|
});
|
|
class MutableToken {
|
|
constructor() {
|
|
this._isCancelled = false;
|
|
}
|
|
cancel() {
|
|
if (!this._isCancelled) {
|
|
this._isCancelled = true;
|
|
if (this._emitter) {
|
|
this._emitter.fire(undefined);
|
|
this.dispose();
|
|
}
|
|
}
|
|
}
|
|
get isCancellationRequested() {
|
|
return this._isCancelled;
|
|
}
|
|
get onCancellationRequested() {
|
|
if (this._isCancelled) {
|
|
return shortcutEvent;
|
|
}
|
|
if (!this._emitter) {
|
|
this._emitter = new events_1.Emitter();
|
|
}
|
|
return this._emitter.event;
|
|
}
|
|
dispose() {
|
|
if (this._emitter) {
|
|
this._emitter.dispose();
|
|
this._emitter = undefined;
|
|
}
|
|
}
|
|
}
|
|
class CancellationTokenSource {
|
|
get token() {
|
|
if (!this._token) {
|
|
// be lazy and create the token only when
|
|
// actually needed
|
|
this._token = new MutableToken();
|
|
}
|
|
return this._token;
|
|
}
|
|
cancel() {
|
|
if (!this._token) {
|
|
// save an object by returning the default
|
|
// cancelled token when cancellation happens
|
|
// before someone asks for the token
|
|
this._token = CancellationToken.Cancelled;
|
|
}
|
|
else {
|
|
this._token.cancel();
|
|
}
|
|
}
|
|
dispose() {
|
|
if (!this._token) {
|
|
// ensure to initialize with an empty token if we had none
|
|
this._token = CancellationToken.None;
|
|
}
|
|
else if (this._token instanceof MutableToken) {
|
|
// actually dispose
|
|
this._token.dispose();
|
|
}
|
|
}
|
|
}
|
|
exports.CancellationTokenSource = CancellationTokenSource;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4054:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.createMessageConnection = exports.ConnectionOptions = exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.Trace = exports.NullLogger = exports.ProgressType = exports.ProgressToken = void 0;
|
|
const ral_1 = __webpack_require__(5091);
|
|
const Is = __webpack_require__(6618);
|
|
const messages_1 = __webpack_require__(7162);
|
|
const linkedMap_1 = __webpack_require__(1109);
|
|
const events_1 = __webpack_require__(2479);
|
|
const cancellation_1 = __webpack_require__(6957);
|
|
var CancelNotification;
|
|
(function (CancelNotification) {
|
|
CancelNotification.type = new messages_1.NotificationType('$/cancelRequest');
|
|
})(CancelNotification || (CancelNotification = {}));
|
|
var ProgressToken;
|
|
(function (ProgressToken) {
|
|
function is(value) {
|
|
return typeof value === 'string' || typeof value === 'number';
|
|
}
|
|
ProgressToken.is = is;
|
|
})(ProgressToken = exports.ProgressToken || (exports.ProgressToken = {}));
|
|
var ProgressNotification;
|
|
(function (ProgressNotification) {
|
|
ProgressNotification.type = new messages_1.NotificationType('$/progress');
|
|
})(ProgressNotification || (ProgressNotification = {}));
|
|
class ProgressType {
|
|
constructor() {
|
|
}
|
|
}
|
|
exports.ProgressType = ProgressType;
|
|
var StarRequestHandler;
|
|
(function (StarRequestHandler) {
|
|
function is(value) {
|
|
return Is.func(value);
|
|
}
|
|
StarRequestHandler.is = is;
|
|
})(StarRequestHandler || (StarRequestHandler = {}));
|
|
exports.NullLogger = Object.freeze({
|
|
error: () => { },
|
|
warn: () => { },
|
|
info: () => { },
|
|
log: () => { }
|
|
});
|
|
var Trace;
|
|
(function (Trace) {
|
|
Trace[Trace["Off"] = 0] = "Off";
|
|
Trace[Trace["Messages"] = 1] = "Messages";
|
|
Trace[Trace["Compact"] = 2] = "Compact";
|
|
Trace[Trace["Verbose"] = 3] = "Verbose";
|
|
})(Trace = exports.Trace || (exports.Trace = {}));
|
|
var TraceValues;
|
|
(function (TraceValues) {
|
|
/**
|
|
* Turn tracing off.
|
|
*/
|
|
TraceValues.Off = 'off';
|
|
/**
|
|
* Trace messages only.
|
|
*/
|
|
TraceValues.Messages = 'messages';
|
|
/**
|
|
* Compact message tracing.
|
|
*/
|
|
TraceValues.Compact = 'compact';
|
|
/**
|
|
* Verbose message tracing.
|
|
*/
|
|
TraceValues.Verbose = 'verbose';
|
|
})(TraceValues = exports.TraceValues || (exports.TraceValues = {}));
|
|
(function (Trace) {
|
|
function fromString(value) {
|
|
if (!Is.string(value)) {
|
|
return Trace.Off;
|
|
}
|
|
value = value.toLowerCase();
|
|
switch (value) {
|
|
case 'off':
|
|
return Trace.Off;
|
|
case 'messages':
|
|
return Trace.Messages;
|
|
case 'compact':
|
|
return Trace.Compact;
|
|
case 'verbose':
|
|
return Trace.Verbose;
|
|
default:
|
|
return Trace.Off;
|
|
}
|
|
}
|
|
Trace.fromString = fromString;
|
|
function toString(value) {
|
|
switch (value) {
|
|
case Trace.Off:
|
|
return 'off';
|
|
case Trace.Messages:
|
|
return 'messages';
|
|
case Trace.Compact:
|
|
return 'compact';
|
|
case Trace.Verbose:
|
|
return 'verbose';
|
|
default:
|
|
return 'off';
|
|
}
|
|
}
|
|
Trace.toString = toString;
|
|
})(Trace = exports.Trace || (exports.Trace = {}));
|
|
var TraceFormat;
|
|
(function (TraceFormat) {
|
|
TraceFormat["Text"] = "text";
|
|
TraceFormat["JSON"] = "json";
|
|
})(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}));
|
|
(function (TraceFormat) {
|
|
function fromString(value) {
|
|
if (!Is.string(value)) {
|
|
return TraceFormat.Text;
|
|
}
|
|
value = value.toLowerCase();
|
|
if (value === 'json') {
|
|
return TraceFormat.JSON;
|
|
}
|
|
else {
|
|
return TraceFormat.Text;
|
|
}
|
|
}
|
|
TraceFormat.fromString = fromString;
|
|
})(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}));
|
|
var SetTraceNotification;
|
|
(function (SetTraceNotification) {
|
|
SetTraceNotification.type = new messages_1.NotificationType('$/setTrace');
|
|
})(SetTraceNotification = exports.SetTraceNotification || (exports.SetTraceNotification = {}));
|
|
var LogTraceNotification;
|
|
(function (LogTraceNotification) {
|
|
LogTraceNotification.type = new messages_1.NotificationType('$/logTrace');
|
|
})(LogTraceNotification = exports.LogTraceNotification || (exports.LogTraceNotification = {}));
|
|
var ConnectionErrors;
|
|
(function (ConnectionErrors) {
|
|
/**
|
|
* The connection is closed.
|
|
*/
|
|
ConnectionErrors[ConnectionErrors["Closed"] = 1] = "Closed";
|
|
/**
|
|
* The connection got disposed.
|
|
*/
|
|
ConnectionErrors[ConnectionErrors["Disposed"] = 2] = "Disposed";
|
|
/**
|
|
* The connection is already in listening mode.
|
|
*/
|
|
ConnectionErrors[ConnectionErrors["AlreadyListening"] = 3] = "AlreadyListening";
|
|
})(ConnectionErrors = exports.ConnectionErrors || (exports.ConnectionErrors = {}));
|
|
class ConnectionError extends Error {
|
|
constructor(code, message) {
|
|
super(message);
|
|
this.code = code;
|
|
Object.setPrototypeOf(this, ConnectionError.prototype);
|
|
}
|
|
}
|
|
exports.ConnectionError = ConnectionError;
|
|
var ConnectionStrategy;
|
|
(function (ConnectionStrategy) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && Is.func(candidate.cancelUndispatched);
|
|
}
|
|
ConnectionStrategy.is = is;
|
|
})(ConnectionStrategy = exports.ConnectionStrategy || (exports.ConnectionStrategy = {}));
|
|
var IdCancellationReceiverStrategy;
|
|
(function (IdCancellationReceiverStrategy) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && (candidate.kind === undefined || candidate.kind === 'id') && Is.func(candidate.createCancellationTokenSource) && (candidate.dispose === undefined || Is.func(candidate.dispose));
|
|
}
|
|
IdCancellationReceiverStrategy.is = is;
|
|
})(IdCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy || (exports.IdCancellationReceiverStrategy = {}));
|
|
var RequestCancellationReceiverStrategy;
|
|
(function (RequestCancellationReceiverStrategy) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && candidate.kind === 'request' && Is.func(candidate.createCancellationTokenSource) && (candidate.dispose === undefined || Is.func(candidate.dispose));
|
|
}
|
|
RequestCancellationReceiverStrategy.is = is;
|
|
})(RequestCancellationReceiverStrategy = exports.RequestCancellationReceiverStrategy || (exports.RequestCancellationReceiverStrategy = {}));
|
|
var CancellationReceiverStrategy;
|
|
(function (CancellationReceiverStrategy) {
|
|
CancellationReceiverStrategy.Message = Object.freeze({
|
|
createCancellationTokenSource(_) {
|
|
return new cancellation_1.CancellationTokenSource();
|
|
}
|
|
});
|
|
function is(value) {
|
|
return IdCancellationReceiverStrategy.is(value) || RequestCancellationReceiverStrategy.is(value);
|
|
}
|
|
CancellationReceiverStrategy.is = is;
|
|
})(CancellationReceiverStrategy = exports.CancellationReceiverStrategy || (exports.CancellationReceiverStrategy = {}));
|
|
var CancellationSenderStrategy;
|
|
(function (CancellationSenderStrategy) {
|
|
CancellationSenderStrategy.Message = Object.freeze({
|
|
sendCancellation(conn, id) {
|
|
return conn.sendNotification(CancelNotification.type, { id });
|
|
},
|
|
cleanup(_) { }
|
|
});
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && Is.func(candidate.sendCancellation) && Is.func(candidate.cleanup);
|
|
}
|
|
CancellationSenderStrategy.is = is;
|
|
})(CancellationSenderStrategy = exports.CancellationSenderStrategy || (exports.CancellationSenderStrategy = {}));
|
|
var CancellationStrategy;
|
|
(function (CancellationStrategy) {
|
|
CancellationStrategy.Message = Object.freeze({
|
|
receiver: CancellationReceiverStrategy.Message,
|
|
sender: CancellationSenderStrategy.Message
|
|
});
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
|
|
}
|
|
CancellationStrategy.is = is;
|
|
})(CancellationStrategy = exports.CancellationStrategy || (exports.CancellationStrategy = {}));
|
|
var MessageStrategy;
|
|
(function (MessageStrategy) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && Is.func(candidate.handleMessage);
|
|
}
|
|
MessageStrategy.is = is;
|
|
})(MessageStrategy = exports.MessageStrategy || (exports.MessageStrategy = {}));
|
|
var ConnectionOptions;
|
|
(function (ConnectionOptions) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy) || MessageStrategy.is(candidate.messageStrategy));
|
|
}
|
|
ConnectionOptions.is = is;
|
|
})(ConnectionOptions = exports.ConnectionOptions || (exports.ConnectionOptions = {}));
|
|
var ConnectionState;
|
|
(function (ConnectionState) {
|
|
ConnectionState[ConnectionState["New"] = 1] = "New";
|
|
ConnectionState[ConnectionState["Listening"] = 2] = "Listening";
|
|
ConnectionState[ConnectionState["Closed"] = 3] = "Closed";
|
|
ConnectionState[ConnectionState["Disposed"] = 4] = "Disposed";
|
|
})(ConnectionState || (ConnectionState = {}));
|
|
function createMessageConnection(messageReader, messageWriter, _logger, options) {
|
|
const logger = _logger !== undefined ? _logger : exports.NullLogger;
|
|
let sequenceNumber = 0;
|
|
let notificationSequenceNumber = 0;
|
|
let unknownResponseSequenceNumber = 0;
|
|
const version = '2.0';
|
|
let starRequestHandler = undefined;
|
|
const requestHandlers = new Map();
|
|
let starNotificationHandler = undefined;
|
|
const notificationHandlers = new Map();
|
|
const progressHandlers = new Map();
|
|
let timer;
|
|
let messageQueue = new linkedMap_1.LinkedMap();
|
|
let responsePromises = new Map();
|
|
let knownCanceledRequests = new Set();
|
|
let requestTokens = new Map();
|
|
let trace = Trace.Off;
|
|
let traceFormat = TraceFormat.Text;
|
|
let tracer;
|
|
let state = ConnectionState.New;
|
|
const errorEmitter = new events_1.Emitter();
|
|
const closeEmitter = new events_1.Emitter();
|
|
const unhandledNotificationEmitter = new events_1.Emitter();
|
|
const unhandledProgressEmitter = new events_1.Emitter();
|
|
const disposeEmitter = new events_1.Emitter();
|
|
const cancellationStrategy = (options && options.cancellationStrategy) ? options.cancellationStrategy : CancellationStrategy.Message;
|
|
function createRequestQueueKey(id) {
|
|
if (id === null) {
|
|
throw new Error(`Can't send requests with id null since the response can't be correlated.`);
|
|
}
|
|
return 'req-' + id.toString();
|
|
}
|
|
function createResponseQueueKey(id) {
|
|
if (id === null) {
|
|
return 'res-unknown-' + (++unknownResponseSequenceNumber).toString();
|
|
}
|
|
else {
|
|
return 'res-' + id.toString();
|
|
}
|
|
}
|
|
function createNotificationQueueKey() {
|
|
return 'not-' + (++notificationSequenceNumber).toString();
|
|
}
|
|
function addMessageToQueue(queue, message) {
|
|
if (messages_1.Message.isRequest(message)) {
|
|
queue.set(createRequestQueueKey(message.id), message);
|
|
}
|
|
else if (messages_1.Message.isResponse(message)) {
|
|
queue.set(createResponseQueueKey(message.id), message);
|
|
}
|
|
else {
|
|
queue.set(createNotificationQueueKey(), message);
|
|
}
|
|
}
|
|
function cancelUndispatched(_message) {
|
|
return undefined;
|
|
}
|
|
function isListening() {
|
|
return state === ConnectionState.Listening;
|
|
}
|
|
function isClosed() {
|
|
return state === ConnectionState.Closed;
|
|
}
|
|
function isDisposed() {
|
|
return state === ConnectionState.Disposed;
|
|
}
|
|
function closeHandler() {
|
|
if (state === ConnectionState.New || state === ConnectionState.Listening) {
|
|
state = ConnectionState.Closed;
|
|
closeEmitter.fire(undefined);
|
|
}
|
|
// If the connection is disposed don't sent close events.
|
|
}
|
|
function readErrorHandler(error) {
|
|
errorEmitter.fire([error, undefined, undefined]);
|
|
}
|
|
function writeErrorHandler(data) {
|
|
errorEmitter.fire(data);
|
|
}
|
|
messageReader.onClose(closeHandler);
|
|
messageReader.onError(readErrorHandler);
|
|
messageWriter.onClose(closeHandler);
|
|
messageWriter.onError(writeErrorHandler);
|
|
function triggerMessageQueue() {
|
|
if (timer || messageQueue.size === 0) {
|
|
return;
|
|
}
|
|
timer = (0, ral_1.default)().timer.setImmediate(() => {
|
|
timer = undefined;
|
|
processMessageQueue();
|
|
});
|
|
}
|
|
function handleMessage(message) {
|
|
if (messages_1.Message.isRequest(message)) {
|
|
handleRequest(message);
|
|
}
|
|
else if (messages_1.Message.isNotification(message)) {
|
|
handleNotification(message);
|
|
}
|
|
else if (messages_1.Message.isResponse(message)) {
|
|
handleResponse(message);
|
|
}
|
|
else {
|
|
handleInvalidMessage(message);
|
|
}
|
|
}
|
|
function processMessageQueue() {
|
|
if (messageQueue.size === 0) {
|
|
return;
|
|
}
|
|
const message = messageQueue.shift();
|
|
try {
|
|
const messageStrategy = options?.messageStrategy;
|
|
if (MessageStrategy.is(messageStrategy)) {
|
|
messageStrategy.handleMessage(message, handleMessage);
|
|
}
|
|
else {
|
|
handleMessage(message);
|
|
}
|
|
}
|
|
finally {
|
|
triggerMessageQueue();
|
|
}
|
|
}
|
|
const callback = (message) => {
|
|
try {
|
|
// We have received a cancellation message. Check if the message is still in the queue
|
|
// and cancel it if allowed to do so.
|
|
if (messages_1.Message.isNotification(message) && message.method === CancelNotification.type.method) {
|
|
const cancelId = message.params.id;
|
|
const key = createRequestQueueKey(cancelId);
|
|
const toCancel = messageQueue.get(key);
|
|
if (messages_1.Message.isRequest(toCancel)) {
|
|
const strategy = options?.connectionStrategy;
|
|
const response = (strategy && strategy.cancelUndispatched) ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
|
|
if (response && (response.error !== undefined || response.result !== undefined)) {
|
|
messageQueue.delete(key);
|
|
requestTokens.delete(cancelId);
|
|
response.id = toCancel.id;
|
|
traceSendingResponse(response, message.method, Date.now());
|
|
messageWriter.write(response).catch(() => logger.error(`Sending response for canceled message failed.`));
|
|
return;
|
|
}
|
|
}
|
|
const cancellationToken = requestTokens.get(cancelId);
|
|
// The request is already running. Cancel the token
|
|
if (cancellationToken !== undefined) {
|
|
cancellationToken.cancel();
|
|
traceReceivedNotification(message);
|
|
return;
|
|
}
|
|
else {
|
|
// Remember the cancel but still queue the message to
|
|
// clean up state in process message.
|
|
knownCanceledRequests.add(cancelId);
|
|
}
|
|
}
|
|
addMessageToQueue(messageQueue, message);
|
|
}
|
|
finally {
|
|
triggerMessageQueue();
|
|
}
|
|
};
|
|
function handleRequest(requestMessage) {
|
|
if (isDisposed()) {
|
|
// we return here silently since we fired an event when the
|
|
// connection got disposed.
|
|
return;
|
|
}
|
|
function reply(resultOrError, method, startTime) {
|
|
const message = {
|
|
jsonrpc: version,
|
|
id: requestMessage.id
|
|
};
|
|
if (resultOrError instanceof messages_1.ResponseError) {
|
|
message.error = resultOrError.toJson();
|
|
}
|
|
else {
|
|
message.result = resultOrError === undefined ? null : resultOrError;
|
|
}
|
|
traceSendingResponse(message, method, startTime);
|
|
messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
|
|
}
|
|
function replyError(error, method, startTime) {
|
|
const message = {
|
|
jsonrpc: version,
|
|
id: requestMessage.id,
|
|
error: error.toJson()
|
|
};
|
|
traceSendingResponse(message, method, startTime);
|
|
messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
|
|
}
|
|
function replySuccess(result, method, startTime) {
|
|
// The JSON RPC defines that a response must either have a result or an error
|
|
// So we can't treat undefined as a valid response result.
|
|
if (result === undefined) {
|
|
result = null;
|
|
}
|
|
const message = {
|
|
jsonrpc: version,
|
|
id: requestMessage.id,
|
|
result: result
|
|
};
|
|
traceSendingResponse(message, method, startTime);
|
|
messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
|
|
}
|
|
traceReceivedRequest(requestMessage);
|
|
const element = requestHandlers.get(requestMessage.method);
|
|
let type;
|
|
let requestHandler;
|
|
if (element) {
|
|
type = element.type;
|
|
requestHandler = element.handler;
|
|
}
|
|
const startTime = Date.now();
|
|
if (requestHandler || starRequestHandler) {
|
|
const tokenKey = requestMessage.id ?? String(Date.now()); //
|
|
const cancellationSource = IdCancellationReceiverStrategy.is(cancellationStrategy.receiver)
|
|
? cancellationStrategy.receiver.createCancellationTokenSource(tokenKey)
|
|
: cancellationStrategy.receiver.createCancellationTokenSource(requestMessage);
|
|
if (requestMessage.id !== null && knownCanceledRequests.has(requestMessage.id)) {
|
|
cancellationSource.cancel();
|
|
}
|
|
if (requestMessage.id !== null) {
|
|
requestTokens.set(tokenKey, cancellationSource);
|
|
}
|
|
try {
|
|
let handlerResult;
|
|
if (requestHandler) {
|
|
if (requestMessage.params === undefined) {
|
|
if (type !== undefined && type.numberOfParams !== 0) {
|
|
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.`), requestMessage.method, startTime);
|
|
return;
|
|
}
|
|
handlerResult = requestHandler(cancellationSource.token);
|
|
}
|
|
else if (Array.isArray(requestMessage.params)) {
|
|
if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byName) {
|
|
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
|
|
return;
|
|
}
|
|
handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
|
|
}
|
|
else {
|
|
if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
|
|
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
|
|
return;
|
|
}
|
|
handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
|
|
}
|
|
}
|
|
else if (starRequestHandler) {
|
|
handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
|
|
}
|
|
const promise = handlerResult;
|
|
if (!handlerResult) {
|
|
requestTokens.delete(tokenKey);
|
|
replySuccess(handlerResult, requestMessage.method, startTime);
|
|
}
|
|
else if (promise.then) {
|
|
promise.then((resultOrError) => {
|
|
requestTokens.delete(tokenKey);
|
|
reply(resultOrError, requestMessage.method, startTime);
|
|
}, error => {
|
|
requestTokens.delete(tokenKey);
|
|
if (error instanceof messages_1.ResponseError) {
|
|
replyError(error, requestMessage.method, startTime);
|
|
}
|
|
else if (error && Is.string(error.message)) {
|
|
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
|
|
}
|
|
else {
|
|
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
requestTokens.delete(tokenKey);
|
|
reply(handlerResult, requestMessage.method, startTime);
|
|
}
|
|
}
|
|
catch (error) {
|
|
requestTokens.delete(tokenKey);
|
|
if (error instanceof messages_1.ResponseError) {
|
|
reply(error, requestMessage.method, startTime);
|
|
}
|
|
else if (error && Is.string(error.message)) {
|
|
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
|
|
}
|
|
else {
|
|
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
|
|
}
|
|
}
|
|
function handleResponse(responseMessage) {
|
|
if (isDisposed()) {
|
|
// See handle request.
|
|
return;
|
|
}
|
|
if (responseMessage.id === null) {
|
|
if (responseMessage.error) {
|
|
logger.error(`Received response message without id: Error is: \n${JSON.stringify(responseMessage.error, undefined, 4)}`);
|
|
}
|
|
else {
|
|
logger.error(`Received response message without id. No further error information provided.`);
|
|
}
|
|
}
|
|
else {
|
|
const key = responseMessage.id;
|
|
const responsePromise = responsePromises.get(key);
|
|
traceReceivedResponse(responseMessage, responsePromise);
|
|
if (responsePromise !== undefined) {
|
|
responsePromises.delete(key);
|
|
try {
|
|
if (responseMessage.error) {
|
|
const error = responseMessage.error;
|
|
responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));
|
|
}
|
|
else if (responseMessage.result !== undefined) {
|
|
responsePromise.resolve(responseMessage.result);
|
|
}
|
|
else {
|
|
throw new Error('Should never happen.');
|
|
}
|
|
}
|
|
catch (error) {
|
|
if (error.message) {
|
|
logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);
|
|
}
|
|
else {
|
|
logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function handleNotification(message) {
|
|
if (isDisposed()) {
|
|
// See handle request.
|
|
return;
|
|
}
|
|
let type = undefined;
|
|
let notificationHandler;
|
|
if (message.method === CancelNotification.type.method) {
|
|
const cancelId = message.params.id;
|
|
knownCanceledRequests.delete(cancelId);
|
|
traceReceivedNotification(message);
|
|
return;
|
|
}
|
|
else {
|
|
const element = notificationHandlers.get(message.method);
|
|
if (element) {
|
|
notificationHandler = element.handler;
|
|
type = element.type;
|
|
}
|
|
}
|
|
if (notificationHandler || starNotificationHandler) {
|
|
try {
|
|
traceReceivedNotification(message);
|
|
if (notificationHandler) {
|
|
if (message.params === undefined) {
|
|
if (type !== undefined) {
|
|
if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) {
|
|
logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received none.`);
|
|
}
|
|
}
|
|
notificationHandler();
|
|
}
|
|
else if (Array.isArray(message.params)) {
|
|
// There are JSON-RPC libraries that send progress message as positional params although
|
|
// specified as named. So convert them if this is the case.
|
|
const params = message.params;
|
|
if (message.method === ProgressNotification.type.method && params.length === 2 && ProgressToken.is(params[0])) {
|
|
notificationHandler({ token: params[0], value: params[1] });
|
|
}
|
|
else {
|
|
if (type !== undefined) {
|
|
if (type.parameterStructures === messages_1.ParameterStructures.byName) {
|
|
logger.error(`Notification ${message.method} defines parameters by name but received parameters by position`);
|
|
}
|
|
if (type.numberOfParams !== message.params.length) {
|
|
logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments`);
|
|
}
|
|
}
|
|
notificationHandler(...params);
|
|
}
|
|
}
|
|
else {
|
|
if (type !== undefined && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
|
|
logger.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
|
|
}
|
|
notificationHandler(message.params);
|
|
}
|
|
}
|
|
else if (starNotificationHandler) {
|
|
starNotificationHandler(message.method, message.params);
|
|
}
|
|
}
|
|
catch (error) {
|
|
if (error.message) {
|
|
logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
|
|
}
|
|
else {
|
|
logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
unhandledNotificationEmitter.fire(message);
|
|
}
|
|
}
|
|
function handleInvalidMessage(message) {
|
|
if (!message) {
|
|
logger.error('Received empty message.');
|
|
return;
|
|
}
|
|
logger.error(`Received message which is neither a response nor a notification message:\n${JSON.stringify(message, null, 4)}`);
|
|
// Test whether we find an id to reject the promise
|
|
const responseMessage = message;
|
|
if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {
|
|
const key = responseMessage.id;
|
|
const responseHandler = responsePromises.get(key);
|
|
if (responseHandler) {
|
|
responseHandler.reject(new Error('The received response has neither a result nor an error property.'));
|
|
}
|
|
}
|
|
}
|
|
function stringifyTrace(params) {
|
|
if (params === undefined || params === null) {
|
|
return undefined;
|
|
}
|
|
switch (trace) {
|
|
case Trace.Verbose:
|
|
return JSON.stringify(params, null, 4);
|
|
case Trace.Compact:
|
|
return JSON.stringify(params);
|
|
default:
|
|
return undefined;
|
|
}
|
|
}
|
|
function traceSendingRequest(message) {
|
|
if (trace === Trace.Off || !tracer) {
|
|
return;
|
|
}
|
|
if (traceFormat === TraceFormat.Text) {
|
|
let data = undefined;
|
|
if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
|
|
data = `Params: ${stringifyTrace(message.params)}\n\n`;
|
|
}
|
|
tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
|
|
}
|
|
else {
|
|
logLSPMessage('send-request', message);
|
|
}
|
|
}
|
|
function traceSendingNotification(message) {
|
|
if (trace === Trace.Off || !tracer) {
|
|
return;
|
|
}
|
|
if (traceFormat === TraceFormat.Text) {
|
|
let data = undefined;
|
|
if (trace === Trace.Verbose || trace === Trace.Compact) {
|
|
if (message.params) {
|
|
data = `Params: ${stringifyTrace(message.params)}\n\n`;
|
|
}
|
|
else {
|
|
data = 'No parameters provided.\n\n';
|
|
}
|
|
}
|
|
tracer.log(`Sending notification '${message.method}'.`, data);
|
|
}
|
|
else {
|
|
logLSPMessage('send-notification', message);
|
|
}
|
|
}
|
|
function traceSendingResponse(message, method, startTime) {
|
|
if (trace === Trace.Off || !tracer) {
|
|
return;
|
|
}
|
|
if (traceFormat === TraceFormat.Text) {
|
|
let data = undefined;
|
|
if (trace === Trace.Verbose || trace === Trace.Compact) {
|
|
if (message.error && message.error.data) {
|
|
data = `Error data: ${stringifyTrace(message.error.data)}\n\n`;
|
|
}
|
|
else {
|
|
if (message.result) {
|
|
data = `Result: ${stringifyTrace(message.result)}\n\n`;
|
|
}
|
|
else if (message.error === undefined) {
|
|
data = 'No result returned.\n\n';
|
|
}
|
|
}
|
|
}
|
|
tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
|
|
}
|
|
else {
|
|
logLSPMessage('send-response', message);
|
|
}
|
|
}
|
|
function traceReceivedRequest(message) {
|
|
if (trace === Trace.Off || !tracer) {
|
|
return;
|
|
}
|
|
if (traceFormat === TraceFormat.Text) {
|
|
let data = undefined;
|
|
if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
|
|
data = `Params: ${stringifyTrace(message.params)}\n\n`;
|
|
}
|
|
tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
|
|
}
|
|
else {
|
|
logLSPMessage('receive-request', message);
|
|
}
|
|
}
|
|
function traceReceivedNotification(message) {
|
|
if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) {
|
|
return;
|
|
}
|
|
if (traceFormat === TraceFormat.Text) {
|
|
let data = undefined;
|
|
if (trace === Trace.Verbose || trace === Trace.Compact) {
|
|
if (message.params) {
|
|
data = `Params: ${stringifyTrace(message.params)}\n\n`;
|
|
}
|
|
else {
|
|
data = 'No parameters provided.\n\n';
|
|
}
|
|
}
|
|
tracer.log(`Received notification '${message.method}'.`, data);
|
|
}
|
|
else {
|
|
logLSPMessage('receive-notification', message);
|
|
}
|
|
}
|
|
function traceReceivedResponse(message, responsePromise) {
|
|
if (trace === Trace.Off || !tracer) {
|
|
return;
|
|
}
|
|
if (traceFormat === TraceFormat.Text) {
|
|
let data = undefined;
|
|
if (trace === Trace.Verbose || trace === Trace.Compact) {
|
|
if (message.error && message.error.data) {
|
|
data = `Error data: ${stringifyTrace(message.error.data)}\n\n`;
|
|
}
|
|
else {
|
|
if (message.result) {
|
|
data = `Result: ${stringifyTrace(message.result)}\n\n`;
|
|
}
|
|
else if (message.error === undefined) {
|
|
data = 'No result returned.\n\n';
|
|
}
|
|
}
|
|
}
|
|
if (responsePromise) {
|
|
const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : '';
|
|
tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
|
|
}
|
|
else {
|
|
tracer.log(`Received response ${message.id} without active response promise.`, data);
|
|
}
|
|
}
|
|
else {
|
|
logLSPMessage('receive-response', message);
|
|
}
|
|
}
|
|
function logLSPMessage(type, message) {
|
|
if (!tracer || trace === Trace.Off) {
|
|
return;
|
|
}
|
|
const lspMessage = {
|
|
isLSPMessage: true,
|
|
type,
|
|
message,
|
|
timestamp: Date.now()
|
|
};
|
|
tracer.log(lspMessage);
|
|
}
|
|
function throwIfClosedOrDisposed() {
|
|
if (isClosed()) {
|
|
throw new ConnectionError(ConnectionErrors.Closed, 'Connection is closed.');
|
|
}
|
|
if (isDisposed()) {
|
|
throw new ConnectionError(ConnectionErrors.Disposed, 'Connection is disposed.');
|
|
}
|
|
}
|
|
function throwIfListening() {
|
|
if (isListening()) {
|
|
throw new ConnectionError(ConnectionErrors.AlreadyListening, 'Connection is already listening');
|
|
}
|
|
}
|
|
function throwIfNotListening() {
|
|
if (!isListening()) {
|
|
throw new Error('Call listen() first.');
|
|
}
|
|
}
|
|
function undefinedToNull(param) {
|
|
if (param === undefined) {
|
|
return null;
|
|
}
|
|
else {
|
|
return param;
|
|
}
|
|
}
|
|
function nullToUndefined(param) {
|
|
if (param === null) {
|
|
return undefined;
|
|
}
|
|
else {
|
|
return param;
|
|
}
|
|
}
|
|
function isNamedParam(param) {
|
|
return param !== undefined && param !== null && !Array.isArray(param) && typeof param === 'object';
|
|
}
|
|
function computeSingleParam(parameterStructures, param) {
|
|
switch (parameterStructures) {
|
|
case messages_1.ParameterStructures.auto:
|
|
if (isNamedParam(param)) {
|
|
return nullToUndefined(param);
|
|
}
|
|
else {
|
|
return [undefinedToNull(param)];
|
|
}
|
|
case messages_1.ParameterStructures.byName:
|
|
if (!isNamedParam(param)) {
|
|
throw new Error(`Received parameters by name but param is not an object literal.`);
|
|
}
|
|
return nullToUndefined(param);
|
|
case messages_1.ParameterStructures.byPosition:
|
|
return [undefinedToNull(param)];
|
|
default:
|
|
throw new Error(`Unknown parameter structure ${parameterStructures.toString()}`);
|
|
}
|
|
}
|
|
function computeMessageParams(type, params) {
|
|
let result;
|
|
const numberOfParams = type.numberOfParams;
|
|
switch (numberOfParams) {
|
|
case 0:
|
|
result = undefined;
|
|
break;
|
|
case 1:
|
|
result = computeSingleParam(type.parameterStructures, params[0]);
|
|
break;
|
|
default:
|
|
result = [];
|
|
for (let i = 0; i < params.length && i < numberOfParams; i++) {
|
|
result.push(undefinedToNull(params[i]));
|
|
}
|
|
if (params.length < numberOfParams) {
|
|
for (let i = params.length; i < numberOfParams; i++) {
|
|
result.push(null);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
const connection = {
|
|
sendNotification: (type, ...args) => {
|
|
throwIfClosedOrDisposed();
|
|
let method;
|
|
let messageParams;
|
|
if (Is.string(type)) {
|
|
method = type;
|
|
const first = args[0];
|
|
let paramStart = 0;
|
|
let parameterStructures = messages_1.ParameterStructures.auto;
|
|
if (messages_1.ParameterStructures.is(first)) {
|
|
paramStart = 1;
|
|
parameterStructures = first;
|
|
}
|
|
let paramEnd = args.length;
|
|
const numberOfParams = paramEnd - paramStart;
|
|
switch (numberOfParams) {
|
|
case 0:
|
|
messageParams = undefined;
|
|
break;
|
|
case 1:
|
|
messageParams = computeSingleParam(parameterStructures, args[paramStart]);
|
|
break;
|
|
default:
|
|
if (parameterStructures === messages_1.ParameterStructures.byName) {
|
|
throw new Error(`Received ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
|
|
}
|
|
messageParams = args.slice(paramStart, paramEnd).map(value => undefinedToNull(value));
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
const params = args;
|
|
method = type.method;
|
|
messageParams = computeMessageParams(type, params);
|
|
}
|
|
const notificationMessage = {
|
|
jsonrpc: version,
|
|
method: method,
|
|
params: messageParams
|
|
};
|
|
traceSendingNotification(notificationMessage);
|
|
return messageWriter.write(notificationMessage).catch((error) => {
|
|
logger.error(`Sending notification failed.`);
|
|
throw error;
|
|
});
|
|
},
|
|
onNotification: (type, handler) => {
|
|
throwIfClosedOrDisposed();
|
|
let method;
|
|
if (Is.func(type)) {
|
|
starNotificationHandler = type;
|
|
}
|
|
else if (handler) {
|
|
if (Is.string(type)) {
|
|
method = type;
|
|
notificationHandlers.set(type, { type: undefined, handler });
|
|
}
|
|
else {
|
|
method = type.method;
|
|
notificationHandlers.set(type.method, { type, handler });
|
|
}
|
|
}
|
|
return {
|
|
dispose: () => {
|
|
if (method !== undefined) {
|
|
notificationHandlers.delete(method);
|
|
}
|
|
else {
|
|
starNotificationHandler = undefined;
|
|
}
|
|
}
|
|
};
|
|
},
|
|
onProgress: (_type, token, handler) => {
|
|
if (progressHandlers.has(token)) {
|
|
throw new Error(`Progress handler for token ${token} already registered`);
|
|
}
|
|
progressHandlers.set(token, handler);
|
|
return {
|
|
dispose: () => {
|
|
progressHandlers.delete(token);
|
|
}
|
|
};
|
|
},
|
|
sendProgress: (_type, token, value) => {
|
|
// This should not await but simple return to ensure that we don't have another
|
|
// async scheduling. Otherwise one send could overtake another send.
|
|
return connection.sendNotification(ProgressNotification.type, { token, value });
|
|
},
|
|
onUnhandledProgress: unhandledProgressEmitter.event,
|
|
sendRequest: (type, ...args) => {
|
|
throwIfClosedOrDisposed();
|
|
throwIfNotListening();
|
|
let method;
|
|
let messageParams;
|
|
let token = undefined;
|
|
if (Is.string(type)) {
|
|
method = type;
|
|
const first = args[0];
|
|
const last = args[args.length - 1];
|
|
let paramStart = 0;
|
|
let parameterStructures = messages_1.ParameterStructures.auto;
|
|
if (messages_1.ParameterStructures.is(first)) {
|
|
paramStart = 1;
|
|
parameterStructures = first;
|
|
}
|
|
let paramEnd = args.length;
|
|
if (cancellation_1.CancellationToken.is(last)) {
|
|
paramEnd = paramEnd - 1;
|
|
token = last;
|
|
}
|
|
const numberOfParams = paramEnd - paramStart;
|
|
switch (numberOfParams) {
|
|
case 0:
|
|
messageParams = undefined;
|
|
break;
|
|
case 1:
|
|
messageParams = computeSingleParam(parameterStructures, args[paramStart]);
|
|
break;
|
|
default:
|
|
if (parameterStructures === messages_1.ParameterStructures.byName) {
|
|
throw new Error(`Received ${numberOfParams} parameters for 'by Name' request parameter structure.`);
|
|
}
|
|
messageParams = args.slice(paramStart, paramEnd).map(value => undefinedToNull(value));
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
const params = args;
|
|
method = type.method;
|
|
messageParams = computeMessageParams(type, params);
|
|
const numberOfParams = type.numberOfParams;
|
|
token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : undefined;
|
|
}
|
|
const id = sequenceNumber++;
|
|
let disposable;
|
|
if (token) {
|
|
disposable = token.onCancellationRequested(() => {
|
|
const p = cancellationStrategy.sender.sendCancellation(connection, id);
|
|
if (p === undefined) {
|
|
logger.log(`Received no promise from cancellation strategy when cancelling id ${id}`);
|
|
return Promise.resolve();
|
|
}
|
|
else {
|
|
return p.catch(() => {
|
|
logger.log(`Sending cancellation messages for id ${id} failed`);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
const requestMessage = {
|
|
jsonrpc: version,
|
|
id: id,
|
|
method: method,
|
|
params: messageParams
|
|
};
|
|
traceSendingRequest(requestMessage);
|
|
if (typeof cancellationStrategy.sender.enableCancellation === 'function') {
|
|
cancellationStrategy.sender.enableCancellation(requestMessage);
|
|
}
|
|
return new Promise(async (resolve, reject) => {
|
|
const resolveWithCleanup = (r) => {
|
|
resolve(r);
|
|
cancellationStrategy.sender.cleanup(id);
|
|
disposable?.dispose();
|
|
};
|
|
const rejectWithCleanup = (r) => {
|
|
reject(r);
|
|
cancellationStrategy.sender.cleanup(id);
|
|
disposable?.dispose();
|
|
};
|
|
const responsePromise = { method: method, timerStart: Date.now(), resolve: resolveWithCleanup, reject: rejectWithCleanup };
|
|
try {
|
|
await messageWriter.write(requestMessage);
|
|
responsePromises.set(id, responsePromise);
|
|
}
|
|
catch (error) {
|
|
logger.error(`Sending request failed.`);
|
|
// Writing the message failed. So we need to reject the promise.
|
|
responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, error.message ? error.message : 'Unknown reason'));
|
|
throw error;
|
|
}
|
|
});
|
|
},
|
|
onRequest: (type, handler) => {
|
|
throwIfClosedOrDisposed();
|
|
let method = null;
|
|
if (StarRequestHandler.is(type)) {
|
|
method = undefined;
|
|
starRequestHandler = type;
|
|
}
|
|
else if (Is.string(type)) {
|
|
method = null;
|
|
if (handler !== undefined) {
|
|
method = type;
|
|
requestHandlers.set(type, { handler: handler, type: undefined });
|
|
}
|
|
}
|
|
else {
|
|
if (handler !== undefined) {
|
|
method = type.method;
|
|
requestHandlers.set(type.method, { type, handler });
|
|
}
|
|
}
|
|
return {
|
|
dispose: () => {
|
|
if (method === null) {
|
|
return;
|
|
}
|
|
if (method !== undefined) {
|
|
requestHandlers.delete(method);
|
|
}
|
|
else {
|
|
starRequestHandler = undefined;
|
|
}
|
|
}
|
|
};
|
|
},
|
|
hasPendingResponse: () => {
|
|
return responsePromises.size > 0;
|
|
},
|
|
trace: async (_value, _tracer, sendNotificationOrTraceOptions) => {
|
|
let _sendNotification = false;
|
|
let _traceFormat = TraceFormat.Text;
|
|
if (sendNotificationOrTraceOptions !== undefined) {
|
|
if (Is.boolean(sendNotificationOrTraceOptions)) {
|
|
_sendNotification = sendNotificationOrTraceOptions;
|
|
}
|
|
else {
|
|
_sendNotification = sendNotificationOrTraceOptions.sendNotification || false;
|
|
_traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;
|
|
}
|
|
}
|
|
trace = _value;
|
|
traceFormat = _traceFormat;
|
|
if (trace === Trace.Off) {
|
|
tracer = undefined;
|
|
}
|
|
else {
|
|
tracer = _tracer;
|
|
}
|
|
if (_sendNotification && !isClosed() && !isDisposed()) {
|
|
await connection.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });
|
|
}
|
|
},
|
|
onError: errorEmitter.event,
|
|
onClose: closeEmitter.event,
|
|
onUnhandledNotification: unhandledNotificationEmitter.event,
|
|
onDispose: disposeEmitter.event,
|
|
end: () => {
|
|
messageWriter.end();
|
|
},
|
|
dispose: () => {
|
|
if (isDisposed()) {
|
|
return;
|
|
}
|
|
state = ConnectionState.Disposed;
|
|
disposeEmitter.fire(undefined);
|
|
const error = new messages_1.ResponseError(messages_1.ErrorCodes.PendingResponseRejected, 'Pending response rejected since connection got disposed');
|
|
for (const promise of responsePromises.values()) {
|
|
promise.reject(error);
|
|
}
|
|
responsePromises = new Map();
|
|
requestTokens = new Map();
|
|
knownCanceledRequests = new Set();
|
|
messageQueue = new linkedMap_1.LinkedMap();
|
|
// Test for backwards compatibility
|
|
if (Is.func(messageWriter.dispose)) {
|
|
messageWriter.dispose();
|
|
}
|
|
if (Is.func(messageReader.dispose)) {
|
|
messageReader.dispose();
|
|
}
|
|
},
|
|
listen: () => {
|
|
throwIfClosedOrDisposed();
|
|
throwIfListening();
|
|
state = ConnectionState.Listening;
|
|
messageReader.listen(callback);
|
|
},
|
|
inspect: () => {
|
|
// eslint-disable-next-line no-console
|
|
(0, ral_1.default)().console.log('inspect');
|
|
}
|
|
};
|
|
connection.onNotification(LogTraceNotification.type, (params) => {
|
|
if (trace === Trace.Off || !tracer) {
|
|
return;
|
|
}
|
|
const verbose = trace === Trace.Verbose || trace === Trace.Compact;
|
|
tracer.log(params.message, verbose ? params.verbose : undefined);
|
|
});
|
|
connection.onNotification(ProgressNotification.type, (params) => {
|
|
const handler = progressHandlers.get(params.token);
|
|
if (handler) {
|
|
handler(params.value);
|
|
}
|
|
else {
|
|
unhandledProgressEmitter.fire(params);
|
|
}
|
|
});
|
|
return connection;
|
|
}
|
|
exports.createMessageConnection = createMessageConnection;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8844:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.Disposable = void 0;
|
|
var Disposable;
|
|
(function (Disposable) {
|
|
function create(func) {
|
|
return {
|
|
dispose: func
|
|
};
|
|
}
|
|
Disposable.create = create;
|
|
})(Disposable = exports.Disposable || (exports.Disposable = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2479:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.Emitter = exports.Event = void 0;
|
|
const ral_1 = __webpack_require__(5091);
|
|
var Event;
|
|
(function (Event) {
|
|
const _disposable = { dispose() { } };
|
|
Event.None = function () { return _disposable; };
|
|
})(Event = exports.Event || (exports.Event = {}));
|
|
class CallbackList {
|
|
add(callback, context = null, bucket) {
|
|
if (!this._callbacks) {
|
|
this._callbacks = [];
|
|
this._contexts = [];
|
|
}
|
|
this._callbacks.push(callback);
|
|
this._contexts.push(context);
|
|
if (Array.isArray(bucket)) {
|
|
bucket.push({ dispose: () => this.remove(callback, context) });
|
|
}
|
|
}
|
|
remove(callback, context = null) {
|
|
if (!this._callbacks) {
|
|
return;
|
|
}
|
|
let foundCallbackWithDifferentContext = false;
|
|
for (let i = 0, len = this._callbacks.length; i < len; i++) {
|
|
if (this._callbacks[i] === callback) {
|
|
if (this._contexts[i] === context) {
|
|
// callback & context match => remove it
|
|
this._callbacks.splice(i, 1);
|
|
this._contexts.splice(i, 1);
|
|
return;
|
|
}
|
|
else {
|
|
foundCallbackWithDifferentContext = true;
|
|
}
|
|
}
|
|
}
|
|
if (foundCallbackWithDifferentContext) {
|
|
throw new Error('When adding a listener with a context, you should remove it with the same context');
|
|
}
|
|
}
|
|
invoke(...args) {
|
|
if (!this._callbacks) {
|
|
return [];
|
|
}
|
|
const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
|
|
for (let i = 0, len = callbacks.length; i < len; i++) {
|
|
try {
|
|
ret.push(callbacks[i].apply(contexts[i], args));
|
|
}
|
|
catch (e) {
|
|
// eslint-disable-next-line no-console
|
|
(0, ral_1.default)().console.error(e);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
isEmpty() {
|
|
return !this._callbacks || this._callbacks.length === 0;
|
|
}
|
|
dispose() {
|
|
this._callbacks = undefined;
|
|
this._contexts = undefined;
|
|
}
|
|
}
|
|
class Emitter {
|
|
constructor(_options) {
|
|
this._options = _options;
|
|
}
|
|
/**
|
|
* For the public to allow to subscribe
|
|
* to events from this Emitter
|
|
*/
|
|
get event() {
|
|
if (!this._event) {
|
|
this._event = (listener, thisArgs, disposables) => {
|
|
if (!this._callbacks) {
|
|
this._callbacks = new CallbackList();
|
|
}
|
|
if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
|
|
this._options.onFirstListenerAdd(this);
|
|
}
|
|
this._callbacks.add(listener, thisArgs);
|
|
const result = {
|
|
dispose: () => {
|
|
if (!this._callbacks) {
|
|
// disposable is disposed after emitter is disposed.
|
|
return;
|
|
}
|
|
this._callbacks.remove(listener, thisArgs);
|
|
result.dispose = Emitter._noop;
|
|
if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
|
|
this._options.onLastListenerRemove(this);
|
|
}
|
|
}
|
|
};
|
|
if (Array.isArray(disposables)) {
|
|
disposables.push(result);
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
return this._event;
|
|
}
|
|
/**
|
|
* To be kept private to fire an event to
|
|
* subscribers
|
|
*/
|
|
fire(event) {
|
|
if (this._callbacks) {
|
|
this._callbacks.invoke.call(this._callbacks, event);
|
|
}
|
|
}
|
|
dispose() {
|
|
if (this._callbacks) {
|
|
this._callbacks.dispose();
|
|
this._callbacks = undefined;
|
|
}
|
|
}
|
|
}
|
|
exports.Emitter = Emitter;
|
|
Emitter._noop = function () { };
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6618:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
|
|
function boolean(value) {
|
|
return value === true || value === false;
|
|
}
|
|
exports.boolean = boolean;
|
|
function string(value) {
|
|
return typeof value === 'string' || value instanceof String;
|
|
}
|
|
exports.string = string;
|
|
function number(value) {
|
|
return typeof value === 'number' || value instanceof Number;
|
|
}
|
|
exports.number = number;
|
|
function error(value) {
|
|
return value instanceof Error;
|
|
}
|
|
exports.error = error;
|
|
function func(value) {
|
|
return typeof value === 'function';
|
|
}
|
|
exports.func = func;
|
|
function array(value) {
|
|
return Array.isArray(value);
|
|
}
|
|
exports.array = array;
|
|
function stringArray(value) {
|
|
return array(value) && value.every(elem => string(elem));
|
|
}
|
|
exports.stringArray = stringArray;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1109:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
var _a;
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.LRUCache = exports.LinkedMap = exports.Touch = void 0;
|
|
var Touch;
|
|
(function (Touch) {
|
|
Touch.None = 0;
|
|
Touch.First = 1;
|
|
Touch.AsOld = Touch.First;
|
|
Touch.Last = 2;
|
|
Touch.AsNew = Touch.Last;
|
|
})(Touch = exports.Touch || (exports.Touch = {}));
|
|
class LinkedMap {
|
|
constructor() {
|
|
this[_a] = 'LinkedMap';
|
|
this._map = new Map();
|
|
this._head = undefined;
|
|
this._tail = undefined;
|
|
this._size = 0;
|
|
this._state = 0;
|
|
}
|
|
clear() {
|
|
this._map.clear();
|
|
this._head = undefined;
|
|
this._tail = undefined;
|
|
this._size = 0;
|
|
this._state++;
|
|
}
|
|
isEmpty() {
|
|
return !this._head && !this._tail;
|
|
}
|
|
get size() {
|
|
return this._size;
|
|
}
|
|
get first() {
|
|
return this._head?.value;
|
|
}
|
|
get last() {
|
|
return this._tail?.value;
|
|
}
|
|
has(key) {
|
|
return this._map.has(key);
|
|
}
|
|
get(key, touch = Touch.None) {
|
|
const item = this._map.get(key);
|
|
if (!item) {
|
|
return undefined;
|
|
}
|
|
if (touch !== Touch.None) {
|
|
this.touch(item, touch);
|
|
}
|
|
return item.value;
|
|
}
|
|
set(key, value, touch = Touch.None) {
|
|
let item = this._map.get(key);
|
|
if (item) {
|
|
item.value = value;
|
|
if (touch !== Touch.None) {
|
|
this.touch(item, touch);
|
|
}
|
|
}
|
|
else {
|
|
item = { key, value, next: undefined, previous: undefined };
|
|
switch (touch) {
|
|
case Touch.None:
|
|
this.addItemLast(item);
|
|
break;
|
|
case Touch.First:
|
|
this.addItemFirst(item);
|
|
break;
|
|
case Touch.Last:
|
|
this.addItemLast(item);
|
|
break;
|
|
default:
|
|
this.addItemLast(item);
|
|
break;
|
|
}
|
|
this._map.set(key, item);
|
|
this._size++;
|
|
}
|
|
return this;
|
|
}
|
|
delete(key) {
|
|
return !!this.remove(key);
|
|
}
|
|
remove(key) {
|
|
const item = this._map.get(key);
|
|
if (!item) {
|
|
return undefined;
|
|
}
|
|
this._map.delete(key);
|
|
this.removeItem(item);
|
|
this._size--;
|
|
return item.value;
|
|
}
|
|
shift() {
|
|
if (!this._head && !this._tail) {
|
|
return undefined;
|
|
}
|
|
if (!this._head || !this._tail) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
const item = this._head;
|
|
this._map.delete(item.key);
|
|
this.removeItem(item);
|
|
this._size--;
|
|
return item.value;
|
|
}
|
|
forEach(callbackfn, thisArg) {
|
|
const state = this._state;
|
|
let current = this._head;
|
|
while (current) {
|
|
if (thisArg) {
|
|
callbackfn.bind(thisArg)(current.value, current.key, this);
|
|
}
|
|
else {
|
|
callbackfn(current.value, current.key, this);
|
|
}
|
|
if (this._state !== state) {
|
|
throw new Error(`LinkedMap got modified during iteration.`);
|
|
}
|
|
current = current.next;
|
|
}
|
|
}
|
|
keys() {
|
|
const state = this._state;
|
|
let current = this._head;
|
|
const iterator = {
|
|
[Symbol.iterator]: () => {
|
|
return iterator;
|
|
},
|
|
next: () => {
|
|
if (this._state !== state) {
|
|
throw new Error(`LinkedMap got modified during iteration.`);
|
|
}
|
|
if (current) {
|
|
const result = { value: current.key, done: false };
|
|
current = current.next;
|
|
return result;
|
|
}
|
|
else {
|
|
return { value: undefined, done: true };
|
|
}
|
|
}
|
|
};
|
|
return iterator;
|
|
}
|
|
values() {
|
|
const state = this._state;
|
|
let current = this._head;
|
|
const iterator = {
|
|
[Symbol.iterator]: () => {
|
|
return iterator;
|
|
},
|
|
next: () => {
|
|
if (this._state !== state) {
|
|
throw new Error(`LinkedMap got modified during iteration.`);
|
|
}
|
|
if (current) {
|
|
const result = { value: current.value, done: false };
|
|
current = current.next;
|
|
return result;
|
|
}
|
|
else {
|
|
return { value: undefined, done: true };
|
|
}
|
|
}
|
|
};
|
|
return iterator;
|
|
}
|
|
entries() {
|
|
const state = this._state;
|
|
let current = this._head;
|
|
const iterator = {
|
|
[Symbol.iterator]: () => {
|
|
return iterator;
|
|
},
|
|
next: () => {
|
|
if (this._state !== state) {
|
|
throw new Error(`LinkedMap got modified during iteration.`);
|
|
}
|
|
if (current) {
|
|
const result = { value: [current.key, current.value], done: false };
|
|
current = current.next;
|
|
return result;
|
|
}
|
|
else {
|
|
return { value: undefined, done: true };
|
|
}
|
|
}
|
|
};
|
|
return iterator;
|
|
}
|
|
[(_a = Symbol.toStringTag, Symbol.iterator)]() {
|
|
return this.entries();
|
|
}
|
|
trimOld(newSize) {
|
|
if (newSize >= this.size) {
|
|
return;
|
|
}
|
|
if (newSize === 0) {
|
|
this.clear();
|
|
return;
|
|
}
|
|
let current = this._head;
|
|
let currentSize = this.size;
|
|
while (current && currentSize > newSize) {
|
|
this._map.delete(current.key);
|
|
current = current.next;
|
|
currentSize--;
|
|
}
|
|
this._head = current;
|
|
this._size = currentSize;
|
|
if (current) {
|
|
current.previous = undefined;
|
|
}
|
|
this._state++;
|
|
}
|
|
addItemFirst(item) {
|
|
// First time Insert
|
|
if (!this._head && !this._tail) {
|
|
this._tail = item;
|
|
}
|
|
else if (!this._head) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
else {
|
|
item.next = this._head;
|
|
this._head.previous = item;
|
|
}
|
|
this._head = item;
|
|
this._state++;
|
|
}
|
|
addItemLast(item) {
|
|
// First time Insert
|
|
if (!this._head && !this._tail) {
|
|
this._head = item;
|
|
}
|
|
else if (!this._tail) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
else {
|
|
item.previous = this._tail;
|
|
this._tail.next = item;
|
|
}
|
|
this._tail = item;
|
|
this._state++;
|
|
}
|
|
removeItem(item) {
|
|
if (item === this._head && item === this._tail) {
|
|
this._head = undefined;
|
|
this._tail = undefined;
|
|
}
|
|
else if (item === this._head) {
|
|
// This can only happened if size === 1 which is handle
|
|
// by the case above.
|
|
if (!item.next) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
item.next.previous = undefined;
|
|
this._head = item.next;
|
|
}
|
|
else if (item === this._tail) {
|
|
// This can only happened if size === 1 which is handle
|
|
// by the case above.
|
|
if (!item.previous) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
item.previous.next = undefined;
|
|
this._tail = item.previous;
|
|
}
|
|
else {
|
|
const next = item.next;
|
|
const previous = item.previous;
|
|
if (!next || !previous) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
next.previous = previous;
|
|
previous.next = next;
|
|
}
|
|
item.next = undefined;
|
|
item.previous = undefined;
|
|
this._state++;
|
|
}
|
|
touch(item, touch) {
|
|
if (!this._head || !this._tail) {
|
|
throw new Error('Invalid list');
|
|
}
|
|
if ((touch !== Touch.First && touch !== Touch.Last)) {
|
|
return;
|
|
}
|
|
if (touch === Touch.First) {
|
|
if (item === this._head) {
|
|
return;
|
|
}
|
|
const next = item.next;
|
|
const previous = item.previous;
|
|
// Unlink the item
|
|
if (item === this._tail) {
|
|
// previous must be defined since item was not head but is tail
|
|
// So there are more than on item in the map
|
|
previous.next = undefined;
|
|
this._tail = previous;
|
|
}
|
|
else {
|
|
// Both next and previous are not undefined since item was neither head nor tail.
|
|
next.previous = previous;
|
|
previous.next = next;
|
|
}
|
|
// Insert the node at head
|
|
item.previous = undefined;
|
|
item.next = this._head;
|
|
this._head.previous = item;
|
|
this._head = item;
|
|
this._state++;
|
|
}
|
|
else if (touch === Touch.Last) {
|
|
if (item === this._tail) {
|
|
return;
|
|
}
|
|
const next = item.next;
|
|
const previous = item.previous;
|
|
// Unlink the item.
|
|
if (item === this._head) {
|
|
// next must be defined since item was not tail but is head
|
|
// So there are more than on item in the map
|
|
next.previous = undefined;
|
|
this._head = next;
|
|
}
|
|
else {
|
|
// Both next and previous are not undefined since item was neither head nor tail.
|
|
next.previous = previous;
|
|
previous.next = next;
|
|
}
|
|
item.next = undefined;
|
|
item.previous = this._tail;
|
|
this._tail.next = item;
|
|
this._tail = item;
|
|
this._state++;
|
|
}
|
|
}
|
|
toJSON() {
|
|
const data = [];
|
|
this.forEach((value, key) => {
|
|
data.push([key, value]);
|
|
});
|
|
return data;
|
|
}
|
|
fromJSON(data) {
|
|
this.clear();
|
|
for (const [key, value] of data) {
|
|
this.set(key, value);
|
|
}
|
|
}
|
|
}
|
|
exports.LinkedMap = LinkedMap;
|
|
class LRUCache extends LinkedMap {
|
|
constructor(limit, ratio = 1) {
|
|
super();
|
|
this._limit = limit;
|
|
this._ratio = Math.min(Math.max(0, ratio), 1);
|
|
}
|
|
get limit() {
|
|
return this._limit;
|
|
}
|
|
set limit(limit) {
|
|
this._limit = limit;
|
|
this.checkTrim();
|
|
}
|
|
get ratio() {
|
|
return this._ratio;
|
|
}
|
|
set ratio(ratio) {
|
|
this._ratio = Math.min(Math.max(0, ratio), 1);
|
|
this.checkTrim();
|
|
}
|
|
get(key, touch = Touch.AsNew) {
|
|
return super.get(key, touch);
|
|
}
|
|
peek(key) {
|
|
return super.get(key, Touch.None);
|
|
}
|
|
set(key, value) {
|
|
super.set(key, value, Touch.Last);
|
|
this.checkTrim();
|
|
return this;
|
|
}
|
|
checkTrim() {
|
|
if (this.size > this._limit) {
|
|
this.trimOld(Math.round(this._limit * this._ratio));
|
|
}
|
|
}
|
|
}
|
|
exports.LRUCache = LRUCache;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9805:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.AbstractMessageBuffer = void 0;
|
|
const CR = 13;
|
|
const LF = 10;
|
|
const CRLF = '\r\n';
|
|
class AbstractMessageBuffer {
|
|
constructor(encoding = 'utf-8') {
|
|
this._encoding = encoding;
|
|
this._chunks = [];
|
|
this._totalLength = 0;
|
|
}
|
|
get encoding() {
|
|
return this._encoding;
|
|
}
|
|
append(chunk) {
|
|
const toAppend = typeof chunk === 'string' ? this.fromString(chunk, this._encoding) : chunk;
|
|
this._chunks.push(toAppend);
|
|
this._totalLength += toAppend.byteLength;
|
|
}
|
|
tryReadHeaders(lowerCaseKeys = false) {
|
|
if (this._chunks.length === 0) {
|
|
return undefined;
|
|
}
|
|
let state = 0;
|
|
let chunkIndex = 0;
|
|
let offset = 0;
|
|
let chunkBytesRead = 0;
|
|
row: while (chunkIndex < this._chunks.length) {
|
|
const chunk = this._chunks[chunkIndex];
|
|
offset = 0;
|
|
column: while (offset < chunk.length) {
|
|
const value = chunk[offset];
|
|
switch (value) {
|
|
case CR:
|
|
switch (state) {
|
|
case 0:
|
|
state = 1;
|
|
break;
|
|
case 2:
|
|
state = 3;
|
|
break;
|
|
default:
|
|
state = 0;
|
|
}
|
|
break;
|
|
case LF:
|
|
switch (state) {
|
|
case 1:
|
|
state = 2;
|
|
break;
|
|
case 3:
|
|
state = 4;
|
|
offset++;
|
|
break row;
|
|
default:
|
|
state = 0;
|
|
}
|
|
break;
|
|
default:
|
|
state = 0;
|
|
}
|
|
offset++;
|
|
}
|
|
chunkBytesRead += chunk.byteLength;
|
|
chunkIndex++;
|
|
}
|
|
if (state !== 4) {
|
|
return undefined;
|
|
}
|
|
// The buffer contains the two CRLF at the end. So we will
|
|
// have two empty lines after the split at the end as well.
|
|
const buffer = this._read(chunkBytesRead + offset);
|
|
const result = new Map();
|
|
const headers = this.toString(buffer, 'ascii').split(CRLF);
|
|
if (headers.length < 2) {
|
|
return result;
|
|
}
|
|
for (let i = 0; i < headers.length - 2; i++) {
|
|
const header = headers[i];
|
|
const index = header.indexOf(':');
|
|
if (index === -1) {
|
|
throw new Error('Message header must separate key and value using :');
|
|
}
|
|
const key = header.substr(0, index);
|
|
const value = header.substr(index + 1).trim();
|
|
result.set(lowerCaseKeys ? key.toLowerCase() : key, value);
|
|
}
|
|
return result;
|
|
}
|
|
tryReadBody(length) {
|
|
if (this._totalLength < length) {
|
|
return undefined;
|
|
}
|
|
return this._read(length);
|
|
}
|
|
get numberOfBytes() {
|
|
return this._totalLength;
|
|
}
|
|
_read(byteCount) {
|
|
if (byteCount === 0) {
|
|
return this.emptyBuffer();
|
|
}
|
|
if (byteCount > this._totalLength) {
|
|
throw new Error(`Cannot read so many bytes!`);
|
|
}
|
|
if (this._chunks[0].byteLength === byteCount) {
|
|
// super fast path, precisely first chunk must be returned
|
|
const chunk = this._chunks[0];
|
|
this._chunks.shift();
|
|
this._totalLength -= byteCount;
|
|
return this.asNative(chunk);
|
|
}
|
|
if (this._chunks[0].byteLength > byteCount) {
|
|
// fast path, the reading is entirely within the first chunk
|
|
const chunk = this._chunks[0];
|
|
const result = this.asNative(chunk, byteCount);
|
|
this._chunks[0] = chunk.slice(byteCount);
|
|
this._totalLength -= byteCount;
|
|
return result;
|
|
}
|
|
const result = this.allocNative(byteCount);
|
|
let resultOffset = 0;
|
|
let chunkIndex = 0;
|
|
while (byteCount > 0) {
|
|
const chunk = this._chunks[chunkIndex];
|
|
if (chunk.byteLength > byteCount) {
|
|
// this chunk will survive
|
|
const chunkPart = chunk.slice(0, byteCount);
|
|
result.set(chunkPart, resultOffset);
|
|
resultOffset += byteCount;
|
|
this._chunks[chunkIndex] = chunk.slice(byteCount);
|
|
this._totalLength -= byteCount;
|
|
byteCount -= byteCount;
|
|
}
|
|
else {
|
|
// this chunk will be entirely read
|
|
result.set(chunk, resultOffset);
|
|
resultOffset += chunk.byteLength;
|
|
this._chunks.shift();
|
|
this._totalLength -= chunk.byteLength;
|
|
byteCount -= chunk.byteLength;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
exports.AbstractMessageBuffer = AbstractMessageBuffer;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 656:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = void 0;
|
|
const ral_1 = __webpack_require__(5091);
|
|
const Is = __webpack_require__(6618);
|
|
const events_1 = __webpack_require__(2479);
|
|
const semaphore_1 = __webpack_require__(418);
|
|
var MessageReader;
|
|
(function (MessageReader) {
|
|
function is(value) {
|
|
let candidate = value;
|
|
return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) &&
|
|
Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);
|
|
}
|
|
MessageReader.is = is;
|
|
})(MessageReader = exports.MessageReader || (exports.MessageReader = {}));
|
|
class AbstractMessageReader {
|
|
constructor() {
|
|
this.errorEmitter = new events_1.Emitter();
|
|
this.closeEmitter = new events_1.Emitter();
|
|
this.partialMessageEmitter = new events_1.Emitter();
|
|
}
|
|
dispose() {
|
|
this.errorEmitter.dispose();
|
|
this.closeEmitter.dispose();
|
|
}
|
|
get onError() {
|
|
return this.errorEmitter.event;
|
|
}
|
|
fireError(error) {
|
|
this.errorEmitter.fire(this.asError(error));
|
|
}
|
|
get onClose() {
|
|
return this.closeEmitter.event;
|
|
}
|
|
fireClose() {
|
|
this.closeEmitter.fire(undefined);
|
|
}
|
|
get onPartialMessage() {
|
|
return this.partialMessageEmitter.event;
|
|
}
|
|
firePartialMessage(info) {
|
|
this.partialMessageEmitter.fire(info);
|
|
}
|
|
asError(error) {
|
|
if (error instanceof Error) {
|
|
return error;
|
|
}
|
|
else {
|
|
return new Error(`Reader received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);
|
|
}
|
|
}
|
|
}
|
|
exports.AbstractMessageReader = AbstractMessageReader;
|
|
var ResolvedMessageReaderOptions;
|
|
(function (ResolvedMessageReaderOptions) {
|
|
function fromOptions(options) {
|
|
let charset;
|
|
let result;
|
|
let contentDecoder;
|
|
const contentDecoders = new Map();
|
|
let contentTypeDecoder;
|
|
const contentTypeDecoders = new Map();
|
|
if (options === undefined || typeof options === 'string') {
|
|
charset = options ?? 'utf-8';
|
|
}
|
|
else {
|
|
charset = options.charset ?? 'utf-8';
|
|
if (options.contentDecoder !== undefined) {
|
|
contentDecoder = options.contentDecoder;
|
|
contentDecoders.set(contentDecoder.name, contentDecoder);
|
|
}
|
|
if (options.contentDecoders !== undefined) {
|
|
for (const decoder of options.contentDecoders) {
|
|
contentDecoders.set(decoder.name, decoder);
|
|
}
|
|
}
|
|
if (options.contentTypeDecoder !== undefined) {
|
|
contentTypeDecoder = options.contentTypeDecoder;
|
|
contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
|
|
}
|
|
if (options.contentTypeDecoders !== undefined) {
|
|
for (const decoder of options.contentTypeDecoders) {
|
|
contentTypeDecoders.set(decoder.name, decoder);
|
|
}
|
|
}
|
|
}
|
|
if (contentTypeDecoder === undefined) {
|
|
contentTypeDecoder = (0, ral_1.default)().applicationJson.decoder;
|
|
contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
|
|
}
|
|
return { charset, contentDecoder, contentDecoders, contentTypeDecoder, contentTypeDecoders };
|
|
}
|
|
ResolvedMessageReaderOptions.fromOptions = fromOptions;
|
|
})(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
|
|
class ReadableStreamMessageReader extends AbstractMessageReader {
|
|
constructor(readable, options) {
|
|
super();
|
|
this.readable = readable;
|
|
this.options = ResolvedMessageReaderOptions.fromOptions(options);
|
|
this.buffer = (0, ral_1.default)().messageBuffer.create(this.options.charset);
|
|
this._partialMessageTimeout = 10000;
|
|
this.nextMessageLength = -1;
|
|
this.messageToken = 0;
|
|
this.readSemaphore = new semaphore_1.Semaphore(1);
|
|
}
|
|
set partialMessageTimeout(timeout) {
|
|
this._partialMessageTimeout = timeout;
|
|
}
|
|
get partialMessageTimeout() {
|
|
return this._partialMessageTimeout;
|
|
}
|
|
listen(callback) {
|
|
this.nextMessageLength = -1;
|
|
this.messageToken = 0;
|
|
this.partialMessageTimer = undefined;
|
|
this.callback = callback;
|
|
const result = this.readable.onData((data) => {
|
|
this.onData(data);
|
|
});
|
|
this.readable.onError((error) => this.fireError(error));
|
|
this.readable.onClose(() => this.fireClose());
|
|
return result;
|
|
}
|
|
onData(data) {
|
|
this.buffer.append(data);
|
|
while (true) {
|
|
if (this.nextMessageLength === -1) {
|
|
const headers = this.buffer.tryReadHeaders(true);
|
|
if (!headers) {
|
|
return;
|
|
}
|
|
const contentLength = headers.get('content-length');
|
|
if (!contentLength) {
|
|
this.fireError(new Error('Header must provide a Content-Length property.'));
|
|
return;
|
|
}
|
|
const length = parseInt(contentLength);
|
|
if (isNaN(length)) {
|
|
this.fireError(new Error('Content-Length value must be a number.'));
|
|
return;
|
|
}
|
|
this.nextMessageLength = length;
|
|
}
|
|
const body = this.buffer.tryReadBody(this.nextMessageLength);
|
|
if (body === undefined) {
|
|
/** We haven't received the full message yet. */
|
|
this.setPartialMessageTimer();
|
|
return;
|
|
}
|
|
this.clearPartialMessageTimer();
|
|
this.nextMessageLength = -1;
|
|
// Make sure that we convert one received message after the
|
|
// other. Otherwise it could happen that a decoding of a second
|
|
// smaller message finished before the decoding of a first larger
|
|
// message and then we would deliver the second message first.
|
|
this.readSemaphore.lock(async () => {
|
|
const bytes = this.options.contentDecoder !== undefined
|
|
? await this.options.contentDecoder.decode(body)
|
|
: body;
|
|
const message = await this.options.contentTypeDecoder.decode(bytes, this.options);
|
|
this.callback(message);
|
|
}).catch((error) => {
|
|
this.fireError(error);
|
|
});
|
|
}
|
|
}
|
|
clearPartialMessageTimer() {
|
|
if (this.partialMessageTimer) {
|
|
this.partialMessageTimer.dispose();
|
|
this.partialMessageTimer = undefined;
|
|
}
|
|
}
|
|
setPartialMessageTimer() {
|
|
this.clearPartialMessageTimer();
|
|
if (this._partialMessageTimeout <= 0) {
|
|
return;
|
|
}
|
|
this.partialMessageTimer = (0, ral_1.default)().timer.setTimeout((token, timeout) => {
|
|
this.partialMessageTimer = undefined;
|
|
if (token === this.messageToken) {
|
|
this.firePartialMessage({ messageToken: token, waitingTime: timeout });
|
|
this.setPartialMessageTimer();
|
|
}
|
|
}, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
|
|
}
|
|
}
|
|
exports.ReadableStreamMessageReader = ReadableStreamMessageReader;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9036:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = void 0;
|
|
const ral_1 = __webpack_require__(5091);
|
|
const Is = __webpack_require__(6618);
|
|
const semaphore_1 = __webpack_require__(418);
|
|
const events_1 = __webpack_require__(2479);
|
|
const ContentLength = 'Content-Length: ';
|
|
const CRLF = '\r\n';
|
|
var MessageWriter;
|
|
(function (MessageWriter) {
|
|
function is(value) {
|
|
let candidate = value;
|
|
return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) &&
|
|
Is.func(candidate.onError) && Is.func(candidate.write);
|
|
}
|
|
MessageWriter.is = is;
|
|
})(MessageWriter = exports.MessageWriter || (exports.MessageWriter = {}));
|
|
class AbstractMessageWriter {
|
|
constructor() {
|
|
this.errorEmitter = new events_1.Emitter();
|
|
this.closeEmitter = new events_1.Emitter();
|
|
}
|
|
dispose() {
|
|
this.errorEmitter.dispose();
|
|
this.closeEmitter.dispose();
|
|
}
|
|
get onError() {
|
|
return this.errorEmitter.event;
|
|
}
|
|
fireError(error, message, count) {
|
|
this.errorEmitter.fire([this.asError(error), message, count]);
|
|
}
|
|
get onClose() {
|
|
return this.closeEmitter.event;
|
|
}
|
|
fireClose() {
|
|
this.closeEmitter.fire(undefined);
|
|
}
|
|
asError(error) {
|
|
if (error instanceof Error) {
|
|
return error;
|
|
}
|
|
else {
|
|
return new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : 'unknown'}`);
|
|
}
|
|
}
|
|
}
|
|
exports.AbstractMessageWriter = AbstractMessageWriter;
|
|
var ResolvedMessageWriterOptions;
|
|
(function (ResolvedMessageWriterOptions) {
|
|
function fromOptions(options) {
|
|
if (options === undefined || typeof options === 'string') {
|
|
return { charset: options ?? 'utf-8', contentTypeEncoder: (0, ral_1.default)().applicationJson.encoder };
|
|
}
|
|
else {
|
|
return { charset: options.charset ?? 'utf-8', contentEncoder: options.contentEncoder, contentTypeEncoder: options.contentTypeEncoder ?? (0, ral_1.default)().applicationJson.encoder };
|
|
}
|
|
}
|
|
ResolvedMessageWriterOptions.fromOptions = fromOptions;
|
|
})(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
|
|
class WriteableStreamMessageWriter extends AbstractMessageWriter {
|
|
constructor(writable, options) {
|
|
super();
|
|
this.writable = writable;
|
|
this.options = ResolvedMessageWriterOptions.fromOptions(options);
|
|
this.errorCount = 0;
|
|
this.writeSemaphore = new semaphore_1.Semaphore(1);
|
|
this.writable.onError((error) => this.fireError(error));
|
|
this.writable.onClose(() => this.fireClose());
|
|
}
|
|
async write(msg) {
|
|
return this.writeSemaphore.lock(async () => {
|
|
const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
|
|
if (this.options.contentEncoder !== undefined) {
|
|
return this.options.contentEncoder.encode(buffer);
|
|
}
|
|
else {
|
|
return buffer;
|
|
}
|
|
});
|
|
return payload.then((buffer) => {
|
|
const headers = [];
|
|
headers.push(ContentLength, buffer.byteLength.toString(), CRLF);
|
|
headers.push(CRLF);
|
|
return this.doWrite(msg, headers, buffer);
|
|
}, (error) => {
|
|
this.fireError(error);
|
|
throw error;
|
|
});
|
|
});
|
|
}
|
|
async doWrite(msg, headers, data) {
|
|
try {
|
|
await this.writable.write(headers.join(''), 'ascii');
|
|
return this.writable.write(data);
|
|
}
|
|
catch (error) {
|
|
this.handleError(error, msg);
|
|
return Promise.reject(error);
|
|
}
|
|
}
|
|
handleError(error, msg) {
|
|
this.errorCount++;
|
|
this.fireError(error, msg, this.errorCount);
|
|
}
|
|
end() {
|
|
this.writable.end();
|
|
}
|
|
}
|
|
exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7162:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType = exports.RequestType0 = exports.AbstractMessageSignature = exports.ParameterStructures = exports.ResponseError = exports.ErrorCodes = void 0;
|
|
const is = __webpack_require__(6618);
|
|
/**
|
|
* Predefined error codes.
|
|
*/
|
|
var ErrorCodes;
|
|
(function (ErrorCodes) {
|
|
// Defined by JSON RPC
|
|
ErrorCodes.ParseError = -32700;
|
|
ErrorCodes.InvalidRequest = -32600;
|
|
ErrorCodes.MethodNotFound = -32601;
|
|
ErrorCodes.InvalidParams = -32602;
|
|
ErrorCodes.InternalError = -32603;
|
|
/**
|
|
* This is the start range of JSON RPC reserved error codes.
|
|
* It doesn't denote a real error code. No application error codes should
|
|
* be defined between the start and end range. For backwards
|
|
* compatibility the `ServerNotInitialized` and the `UnknownErrorCode`
|
|
* are left in the range.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
ErrorCodes.jsonrpcReservedErrorRangeStart = -32099;
|
|
/** @deprecated use jsonrpcReservedErrorRangeStart */
|
|
ErrorCodes.serverErrorStart = -32099;
|
|
/**
|
|
* An error occurred when write a message to the transport layer.
|
|
*/
|
|
ErrorCodes.MessageWriteError = -32099;
|
|
/**
|
|
* An error occurred when reading a message from the transport layer.
|
|
*/
|
|
ErrorCodes.MessageReadError = -32098;
|
|
/**
|
|
* The connection got disposed or lost and all pending responses got
|
|
* rejected.
|
|
*/
|
|
ErrorCodes.PendingResponseRejected = -32097;
|
|
/**
|
|
* The connection is inactive and a use of it failed.
|
|
*/
|
|
ErrorCodes.ConnectionInactive = -32096;
|
|
/**
|
|
* Error code indicating that a server received a notification or
|
|
* request before the server has received the `initialize` request.
|
|
*/
|
|
ErrorCodes.ServerNotInitialized = -32002;
|
|
ErrorCodes.UnknownErrorCode = -32001;
|
|
/**
|
|
* This is the end range of JSON RPC reserved error codes.
|
|
* It doesn't denote a real error code.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
ErrorCodes.jsonrpcReservedErrorRangeEnd = -32000;
|
|
/** @deprecated use jsonrpcReservedErrorRangeEnd */
|
|
ErrorCodes.serverErrorEnd = -32000;
|
|
})(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {}));
|
|
/**
|
|
* An error object return in a response in case a request
|
|
* has failed.
|
|
*/
|
|
class ResponseError extends Error {
|
|
constructor(code, message, data) {
|
|
super(message);
|
|
this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
|
|
this.data = data;
|
|
Object.setPrototypeOf(this, ResponseError.prototype);
|
|
}
|
|
toJson() {
|
|
const result = {
|
|
code: this.code,
|
|
message: this.message
|
|
};
|
|
if (this.data !== undefined) {
|
|
result.data = this.data;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
exports.ResponseError = ResponseError;
|
|
class ParameterStructures {
|
|
constructor(kind) {
|
|
this.kind = kind;
|
|
}
|
|
static is(value) {
|
|
return value === ParameterStructures.auto || value === ParameterStructures.byName || value === ParameterStructures.byPosition;
|
|
}
|
|
toString() {
|
|
return this.kind;
|
|
}
|
|
}
|
|
exports.ParameterStructures = ParameterStructures;
|
|
/**
|
|
* The parameter structure is automatically inferred on the number of parameters
|
|
* and the parameter type in case of a single param.
|
|
*/
|
|
ParameterStructures.auto = new ParameterStructures('auto');
|
|
/**
|
|
* Forces `byPosition` parameter structure. This is useful if you have a single
|
|
* parameter which has a literal type.
|
|
*/
|
|
ParameterStructures.byPosition = new ParameterStructures('byPosition');
|
|
/**
|
|
* Forces `byName` parameter structure. This is only useful when having a single
|
|
* parameter. The library will report errors if used with a different number of
|
|
* parameters.
|
|
*/
|
|
ParameterStructures.byName = new ParameterStructures('byName');
|
|
/**
|
|
* An abstract implementation of a MessageType.
|
|
*/
|
|
class AbstractMessageSignature {
|
|
constructor(method, numberOfParams) {
|
|
this.method = method;
|
|
this.numberOfParams = numberOfParams;
|
|
}
|
|
get parameterStructures() {
|
|
return ParameterStructures.auto;
|
|
}
|
|
}
|
|
exports.AbstractMessageSignature = AbstractMessageSignature;
|
|
/**
|
|
* Classes to type request response pairs
|
|
*/
|
|
class RequestType0 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 0);
|
|
}
|
|
}
|
|
exports.RequestType0 = RequestType0;
|
|
class RequestType extends AbstractMessageSignature {
|
|
constructor(method, _parameterStructures = ParameterStructures.auto) {
|
|
super(method, 1);
|
|
this._parameterStructures = _parameterStructures;
|
|
}
|
|
get parameterStructures() {
|
|
return this._parameterStructures;
|
|
}
|
|
}
|
|
exports.RequestType = RequestType;
|
|
class RequestType1 extends AbstractMessageSignature {
|
|
constructor(method, _parameterStructures = ParameterStructures.auto) {
|
|
super(method, 1);
|
|
this._parameterStructures = _parameterStructures;
|
|
}
|
|
get parameterStructures() {
|
|
return this._parameterStructures;
|
|
}
|
|
}
|
|
exports.RequestType1 = RequestType1;
|
|
class RequestType2 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 2);
|
|
}
|
|
}
|
|
exports.RequestType2 = RequestType2;
|
|
class RequestType3 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 3);
|
|
}
|
|
}
|
|
exports.RequestType3 = RequestType3;
|
|
class RequestType4 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 4);
|
|
}
|
|
}
|
|
exports.RequestType4 = RequestType4;
|
|
class RequestType5 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 5);
|
|
}
|
|
}
|
|
exports.RequestType5 = RequestType5;
|
|
class RequestType6 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 6);
|
|
}
|
|
}
|
|
exports.RequestType6 = RequestType6;
|
|
class RequestType7 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 7);
|
|
}
|
|
}
|
|
exports.RequestType7 = RequestType7;
|
|
class RequestType8 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 8);
|
|
}
|
|
}
|
|
exports.RequestType8 = RequestType8;
|
|
class RequestType9 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 9);
|
|
}
|
|
}
|
|
exports.RequestType9 = RequestType9;
|
|
class NotificationType extends AbstractMessageSignature {
|
|
constructor(method, _parameterStructures = ParameterStructures.auto) {
|
|
super(method, 1);
|
|
this._parameterStructures = _parameterStructures;
|
|
}
|
|
get parameterStructures() {
|
|
return this._parameterStructures;
|
|
}
|
|
}
|
|
exports.NotificationType = NotificationType;
|
|
class NotificationType0 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 0);
|
|
}
|
|
}
|
|
exports.NotificationType0 = NotificationType0;
|
|
class NotificationType1 extends AbstractMessageSignature {
|
|
constructor(method, _parameterStructures = ParameterStructures.auto) {
|
|
super(method, 1);
|
|
this._parameterStructures = _parameterStructures;
|
|
}
|
|
get parameterStructures() {
|
|
return this._parameterStructures;
|
|
}
|
|
}
|
|
exports.NotificationType1 = NotificationType1;
|
|
class NotificationType2 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 2);
|
|
}
|
|
}
|
|
exports.NotificationType2 = NotificationType2;
|
|
class NotificationType3 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 3);
|
|
}
|
|
}
|
|
exports.NotificationType3 = NotificationType3;
|
|
class NotificationType4 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 4);
|
|
}
|
|
}
|
|
exports.NotificationType4 = NotificationType4;
|
|
class NotificationType5 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 5);
|
|
}
|
|
}
|
|
exports.NotificationType5 = NotificationType5;
|
|
class NotificationType6 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 6);
|
|
}
|
|
}
|
|
exports.NotificationType6 = NotificationType6;
|
|
class NotificationType7 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 7);
|
|
}
|
|
}
|
|
exports.NotificationType7 = NotificationType7;
|
|
class NotificationType8 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 8);
|
|
}
|
|
}
|
|
exports.NotificationType8 = NotificationType8;
|
|
class NotificationType9 extends AbstractMessageSignature {
|
|
constructor(method) {
|
|
super(method, 9);
|
|
}
|
|
}
|
|
exports.NotificationType9 = NotificationType9;
|
|
var Message;
|
|
(function (Message) {
|
|
/**
|
|
* Tests if the given message is a request message
|
|
*/
|
|
function isRequest(message) {
|
|
const candidate = message;
|
|
return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
|
|
}
|
|
Message.isRequest = isRequest;
|
|
/**
|
|
* Tests if the given message is a notification message
|
|
*/
|
|
function isNotification(message) {
|
|
const candidate = message;
|
|
return candidate && is.string(candidate.method) && message.id === void 0;
|
|
}
|
|
Message.isNotification = isNotification;
|
|
/**
|
|
* Tests if the given message is a response message
|
|
*/
|
|
function isResponse(message) {
|
|
const candidate = message;
|
|
return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
|
|
}
|
|
Message.isResponse = isResponse;
|
|
})(Message = exports.Message || (exports.Message = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5091:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
let _ral;
|
|
function RAL() {
|
|
if (_ral === undefined) {
|
|
throw new Error(`No runtime abstraction layer installed`);
|
|
}
|
|
return _ral;
|
|
}
|
|
(function (RAL) {
|
|
function install(ral) {
|
|
if (ral === undefined) {
|
|
throw new Error(`No runtime abstraction layer provided`);
|
|
}
|
|
_ral = ral;
|
|
}
|
|
RAL.install = install;
|
|
})(RAL || (RAL = {}));
|
|
exports["default"] = RAL;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 418:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.Semaphore = void 0;
|
|
const ral_1 = __webpack_require__(5091);
|
|
class Semaphore {
|
|
constructor(capacity = 1) {
|
|
if (capacity <= 0) {
|
|
throw new Error('Capacity must be greater than 0');
|
|
}
|
|
this._capacity = capacity;
|
|
this._active = 0;
|
|
this._waiting = [];
|
|
}
|
|
lock(thunk) {
|
|
return new Promise((resolve, reject) => {
|
|
this._waiting.push({ thunk, resolve, reject });
|
|
this.runNext();
|
|
});
|
|
}
|
|
get active() {
|
|
return this._active;
|
|
}
|
|
runNext() {
|
|
if (this._waiting.length === 0 || this._active === this._capacity) {
|
|
return;
|
|
}
|
|
(0, ral_1.default)().timer.setImmediate(() => this.doRunNext());
|
|
}
|
|
doRunNext() {
|
|
if (this._waiting.length === 0 || this._active === this._capacity) {
|
|
return;
|
|
}
|
|
const next = this._waiting.shift();
|
|
this._active++;
|
|
if (this._active > this._capacity) {
|
|
throw new Error(`To many thunks active`);
|
|
}
|
|
try {
|
|
const result = next.thunk();
|
|
if (result instanceof Promise) {
|
|
result.then((value) => {
|
|
this._active--;
|
|
next.resolve(value);
|
|
this.runNext();
|
|
}, (err) => {
|
|
this._active--;
|
|
next.reject(err);
|
|
this.runNext();
|
|
});
|
|
}
|
|
else {
|
|
this._active--;
|
|
next.resolve(result);
|
|
this.runNext();
|
|
}
|
|
}
|
|
catch (err) {
|
|
this._active--;
|
|
next.reject(err);
|
|
this.runNext();
|
|
}
|
|
}
|
|
}
|
|
exports.Semaphore = Semaphore;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3489:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = void 0;
|
|
const cancellation_1 = __webpack_require__(6957);
|
|
var CancellationState;
|
|
(function (CancellationState) {
|
|
CancellationState.Continue = 0;
|
|
CancellationState.Cancelled = 1;
|
|
})(CancellationState || (CancellationState = {}));
|
|
class SharedArraySenderStrategy {
|
|
constructor() {
|
|
this.buffers = new Map();
|
|
}
|
|
enableCancellation(request) {
|
|
if (request.id === null) {
|
|
return;
|
|
}
|
|
const buffer = new SharedArrayBuffer(4);
|
|
const data = new Int32Array(buffer, 0, 1);
|
|
data[0] = CancellationState.Continue;
|
|
this.buffers.set(request.id, buffer);
|
|
request.$cancellationData = buffer;
|
|
}
|
|
async sendCancellation(_conn, id) {
|
|
const buffer = this.buffers.get(id);
|
|
if (buffer === undefined) {
|
|
return;
|
|
}
|
|
const data = new Int32Array(buffer, 0, 1);
|
|
Atomics.store(data, 0, CancellationState.Cancelled);
|
|
}
|
|
cleanup(id) {
|
|
this.buffers.delete(id);
|
|
}
|
|
dispose() {
|
|
this.buffers.clear();
|
|
}
|
|
}
|
|
exports.SharedArraySenderStrategy = SharedArraySenderStrategy;
|
|
class SharedArrayBufferCancellationToken {
|
|
constructor(buffer) {
|
|
this.data = new Int32Array(buffer, 0, 1);
|
|
}
|
|
get isCancellationRequested() {
|
|
return Atomics.load(this.data, 0) === CancellationState.Cancelled;
|
|
}
|
|
get onCancellationRequested() {
|
|
throw new Error(`Cancellation over SharedArrayBuffer doesn't support cancellation events`);
|
|
}
|
|
}
|
|
class SharedArrayBufferCancellationTokenSource {
|
|
constructor(buffer) {
|
|
this.token = new SharedArrayBufferCancellationToken(buffer);
|
|
}
|
|
cancel() {
|
|
}
|
|
dispose() {
|
|
}
|
|
}
|
|
class SharedArrayReceiverStrategy {
|
|
constructor() {
|
|
this.kind = 'request';
|
|
}
|
|
createCancellationTokenSource(request) {
|
|
const buffer = request.$cancellationData;
|
|
if (buffer === undefined) {
|
|
return new cancellation_1.CancellationTokenSource();
|
|
}
|
|
return new SharedArrayBufferCancellationTokenSource(buffer);
|
|
}
|
|
}
|
|
exports.SharedArrayReceiverStrategy = SharedArrayReceiverStrategy;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5501:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
|
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.createProtocolConnection = void 0;
|
|
const browser_1 = __webpack_require__(9208);
|
|
__exportStar(__webpack_require__(9208), exports);
|
|
__exportStar(__webpack_require__(3147), exports);
|
|
function createProtocolConnection(reader, writer, logger, options) {
|
|
return (0, browser_1.createMessageConnection)(reader, writer, logger, options);
|
|
}
|
|
exports.createProtocolConnection = createProtocolConnection;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3147:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
|
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.LSPErrorCodes = exports.createProtocolConnection = void 0;
|
|
__exportStar(__webpack_require__(9110), exports);
|
|
__exportStar(__webpack_require__(7717), exports);
|
|
__exportStar(__webpack_require__(8431), exports);
|
|
__exportStar(__webpack_require__(1815), exports);
|
|
var connection_1 = __webpack_require__(291);
|
|
Object.defineProperty(exports, "createProtocolConnection", ({ enumerable: true, get: function () { return connection_1.createProtocolConnection; } }));
|
|
var LSPErrorCodes;
|
|
(function (LSPErrorCodes) {
|
|
/**
|
|
* This is the start range of LSP reserved error codes.
|
|
* It doesn't denote a real error code.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
LSPErrorCodes.lspReservedErrorRangeStart = -32899;
|
|
/**
|
|
* A request failed but it was syntactically correct, e.g the
|
|
* method name was known and the parameters were valid. The error
|
|
* message should contain human readable information about why
|
|
* the request failed.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
LSPErrorCodes.RequestFailed = -32803;
|
|
/**
|
|
* The server cancelled the request. This error code should
|
|
* only be used for requests that explicitly support being
|
|
* server cancellable.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
LSPErrorCodes.ServerCancelled = -32802;
|
|
/**
|
|
* The server detected that the content of a document got
|
|
* modified outside normal conditions. A server should
|
|
* NOT send this error code if it detects a content change
|
|
* in it unprocessed messages. The result even computed
|
|
* on an older state might still be useful for the client.
|
|
*
|
|
* If a client decides that a result is not of any use anymore
|
|
* the client should cancel the request.
|
|
*/
|
|
LSPErrorCodes.ContentModified = -32801;
|
|
/**
|
|
* The client has canceled a request and a server as detected
|
|
* the cancel.
|
|
*/
|
|
LSPErrorCodes.RequestCancelled = -32800;
|
|
/**
|
|
* This is the end range of LSP reserved error codes.
|
|
* It doesn't denote a real error code.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
LSPErrorCodes.lspReservedErrorRangeEnd = -32800;
|
|
})(LSPErrorCodes = exports.LSPErrorCodes || (exports.LSPErrorCodes = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 291:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.createProtocolConnection = void 0;
|
|
const vscode_jsonrpc_1 = __webpack_require__(9110);
|
|
function createProtocolConnection(input, output, logger, options) {
|
|
if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) {
|
|
options = { connectionStrategy: options };
|
|
}
|
|
return (0, vscode_jsonrpc_1.createMessageConnection)(input, output, logger, options);
|
|
}
|
|
exports.createProtocolConnection = createProtocolConnection;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8431:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.ProtocolNotificationType = exports.ProtocolNotificationType0 = exports.ProtocolRequestType = exports.ProtocolRequestType0 = exports.RegistrationType = exports.MessageDirection = void 0;
|
|
const vscode_jsonrpc_1 = __webpack_require__(9110);
|
|
var MessageDirection;
|
|
(function (MessageDirection) {
|
|
MessageDirection["clientToServer"] = "clientToServer";
|
|
MessageDirection["serverToClient"] = "serverToClient";
|
|
MessageDirection["both"] = "both";
|
|
})(MessageDirection = exports.MessageDirection || (exports.MessageDirection = {}));
|
|
class RegistrationType {
|
|
constructor(method) {
|
|
this.method = method;
|
|
}
|
|
}
|
|
exports.RegistrationType = RegistrationType;
|
|
class ProtocolRequestType0 extends vscode_jsonrpc_1.RequestType0 {
|
|
constructor(method) {
|
|
super(method);
|
|
}
|
|
}
|
|
exports.ProtocolRequestType0 = ProtocolRequestType0;
|
|
class ProtocolRequestType extends vscode_jsonrpc_1.RequestType {
|
|
constructor(method) {
|
|
super(method, vscode_jsonrpc_1.ParameterStructures.byName);
|
|
}
|
|
}
|
|
exports.ProtocolRequestType = ProtocolRequestType;
|
|
class ProtocolNotificationType0 extends vscode_jsonrpc_1.NotificationType0 {
|
|
constructor(method) {
|
|
super(method);
|
|
}
|
|
}
|
|
exports.ProtocolNotificationType0 = ProtocolNotificationType0;
|
|
class ProtocolNotificationType extends vscode_jsonrpc_1.NotificationType {
|
|
constructor(method) {
|
|
super(method, vscode_jsonrpc_1.ParameterStructures.byName);
|
|
}
|
|
}
|
|
exports.ProtocolNotificationType = ProtocolNotificationType;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7602:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) TypeFox, Microsoft and others. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.CallHierarchyPrepareRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A request to result a `CallHierarchyItem` in a document at a given position.
|
|
* Can be used as an input to an incoming or outgoing call hierarchy.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var CallHierarchyPrepareRequest;
|
|
(function (CallHierarchyPrepareRequest) {
|
|
CallHierarchyPrepareRequest.method = 'textDocument/prepareCallHierarchy';
|
|
CallHierarchyPrepareRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
CallHierarchyPrepareRequest.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest.method);
|
|
})(CallHierarchyPrepareRequest = exports.CallHierarchyPrepareRequest || (exports.CallHierarchyPrepareRequest = {}));
|
|
/**
|
|
* A request to resolve the incoming calls for a given `CallHierarchyItem`.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var CallHierarchyIncomingCallsRequest;
|
|
(function (CallHierarchyIncomingCallsRequest) {
|
|
CallHierarchyIncomingCallsRequest.method = 'callHierarchy/incomingCalls';
|
|
CallHierarchyIncomingCallsRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
CallHierarchyIncomingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest.method);
|
|
})(CallHierarchyIncomingCallsRequest = exports.CallHierarchyIncomingCallsRequest || (exports.CallHierarchyIncomingCallsRequest = {}));
|
|
/**
|
|
* A request to resolve the outgoing calls for a given `CallHierarchyItem`.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var CallHierarchyOutgoingCallsRequest;
|
|
(function (CallHierarchyOutgoingCallsRequest) {
|
|
CallHierarchyOutgoingCallsRequest.method = 'callHierarchy/outgoingCalls';
|
|
CallHierarchyOutgoingCallsRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
CallHierarchyOutgoingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest.method);
|
|
})(CallHierarchyOutgoingCallsRequest = exports.CallHierarchyOutgoingCallsRequest || (exports.CallHierarchyOutgoingCallsRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3747:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.ColorPresentationRequest = exports.DocumentColorRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A request to list all color symbols found in a given text document. The request's
|
|
* parameter is of type {@link DocumentColorParams} the
|
|
* response is of type {@link ColorInformation ColorInformation[]} or a Thenable
|
|
* that resolves to such.
|
|
*/
|
|
var DocumentColorRequest;
|
|
(function (DocumentColorRequest) {
|
|
DocumentColorRequest.method = 'textDocument/documentColor';
|
|
DocumentColorRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DocumentColorRequest.type = new messages_1.ProtocolRequestType(DocumentColorRequest.method);
|
|
})(DocumentColorRequest = exports.DocumentColorRequest || (exports.DocumentColorRequest = {}));
|
|
/**
|
|
* A request to list all presentation for a color. The request's
|
|
* parameter is of type {@link ColorPresentationParams} the
|
|
* response is of type {@link ColorInformation ColorInformation[]} or a Thenable
|
|
* that resolves to such.
|
|
*/
|
|
var ColorPresentationRequest;
|
|
(function (ColorPresentationRequest) {
|
|
ColorPresentationRequest.method = 'textDocument/colorPresentation';
|
|
ColorPresentationRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
ColorPresentationRequest.type = new messages_1.ProtocolRequestType(ColorPresentationRequest.method);
|
|
})(ColorPresentationRequest = exports.ColorPresentationRequest || (exports.ColorPresentationRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7639:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.ConfigurationRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
//---- Get Configuration request ----
|
|
/**
|
|
* The 'workspace/configuration' request is sent from the server to the client to fetch a certain
|
|
* configuration setting.
|
|
*
|
|
* This pull model replaces the old push model were the client signaled configuration change via an
|
|
* event. If the server still needs to react to configuration changes (since the server caches the
|
|
* result of `workspace/configuration` requests) the server should register for an empty configuration
|
|
* change event and empty the cache if such an event is received.
|
|
*/
|
|
var ConfigurationRequest;
|
|
(function (ConfigurationRequest) {
|
|
ConfigurationRequest.method = 'workspace/configuration';
|
|
ConfigurationRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
ConfigurationRequest.type = new messages_1.ProtocolRequestType(ConfigurationRequest.method);
|
|
})(ConfigurationRequest = exports.ConfigurationRequest || (exports.ConfigurationRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5581:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.DeclarationRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
// @ts-ignore: to avoid inlining LocationLink as dynamic import
|
|
let __noDynamicImport;
|
|
/**
|
|
* A request to resolve the type definition locations of a symbol at a given text
|
|
* document position. The request's parameter is of type [TextDocumentPositionParams]
|
|
* (#TextDocumentPositionParams) the response is of type {@link Declaration}
|
|
* or a typed array of {@link DeclarationLink} or a Thenable that resolves
|
|
* to such.
|
|
*/
|
|
var DeclarationRequest;
|
|
(function (DeclarationRequest) {
|
|
DeclarationRequest.method = 'textDocument/declaration';
|
|
DeclarationRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DeclarationRequest.type = new messages_1.ProtocolRequestType(DeclarationRequest.method);
|
|
})(DeclarationRequest = exports.DeclarationRequest || (exports.DeclarationRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1494:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.DiagnosticRefreshRequest = exports.WorkspaceDiagnosticRequest = exports.DocumentDiagnosticRequest = exports.DocumentDiagnosticReportKind = exports.DiagnosticServerCancellationData = void 0;
|
|
const vscode_jsonrpc_1 = __webpack_require__(9110);
|
|
const Is = __webpack_require__(8633);
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* @since 3.17.0
|
|
*/
|
|
var DiagnosticServerCancellationData;
|
|
(function (DiagnosticServerCancellationData) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && Is.boolean(candidate.retriggerRequest);
|
|
}
|
|
DiagnosticServerCancellationData.is = is;
|
|
})(DiagnosticServerCancellationData = exports.DiagnosticServerCancellationData || (exports.DiagnosticServerCancellationData = {}));
|
|
/**
|
|
* The document diagnostic report kinds.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var DocumentDiagnosticReportKind;
|
|
(function (DocumentDiagnosticReportKind) {
|
|
/**
|
|
* A diagnostic report with a full
|
|
* set of problems.
|
|
*/
|
|
DocumentDiagnosticReportKind.Full = 'full';
|
|
/**
|
|
* A report indicating that the last
|
|
* returned report is still accurate.
|
|
*/
|
|
DocumentDiagnosticReportKind.Unchanged = 'unchanged';
|
|
})(DocumentDiagnosticReportKind = exports.DocumentDiagnosticReportKind || (exports.DocumentDiagnosticReportKind = {}));
|
|
/**
|
|
* The document diagnostic request definition.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var DocumentDiagnosticRequest;
|
|
(function (DocumentDiagnosticRequest) {
|
|
DocumentDiagnosticRequest.method = 'textDocument/diagnostic';
|
|
DocumentDiagnosticRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DocumentDiagnosticRequest.type = new messages_1.ProtocolRequestType(DocumentDiagnosticRequest.method);
|
|
DocumentDiagnosticRequest.partialResult = new vscode_jsonrpc_1.ProgressType();
|
|
})(DocumentDiagnosticRequest = exports.DocumentDiagnosticRequest || (exports.DocumentDiagnosticRequest = {}));
|
|
/**
|
|
* The workspace diagnostic request definition.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var WorkspaceDiagnosticRequest;
|
|
(function (WorkspaceDiagnosticRequest) {
|
|
WorkspaceDiagnosticRequest.method = 'workspace/diagnostic';
|
|
WorkspaceDiagnosticRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
WorkspaceDiagnosticRequest.type = new messages_1.ProtocolRequestType(WorkspaceDiagnosticRequest.method);
|
|
WorkspaceDiagnosticRequest.partialResult = new vscode_jsonrpc_1.ProgressType();
|
|
})(WorkspaceDiagnosticRequest = exports.WorkspaceDiagnosticRequest || (exports.WorkspaceDiagnosticRequest = {}));
|
|
/**
|
|
* The diagnostic refresh request definition.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var DiagnosticRefreshRequest;
|
|
(function (DiagnosticRefreshRequest) {
|
|
DiagnosticRefreshRequest.method = `workspace/diagnostic/refresh`;
|
|
DiagnosticRefreshRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
DiagnosticRefreshRequest.type = new messages_1.ProtocolRequestType0(DiagnosticRefreshRequest.method);
|
|
})(DiagnosticRefreshRequest = exports.DiagnosticRefreshRequest || (exports.DiagnosticRefreshRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4781:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.DidRenameFilesNotification = exports.WillRenameFilesRequest = exports.DidCreateFilesNotification = exports.WillCreateFilesRequest = exports.FileOperationPatternKind = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A pattern kind describing if a glob pattern matches a file a folder or
|
|
* both.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var FileOperationPatternKind;
|
|
(function (FileOperationPatternKind) {
|
|
/**
|
|
* The pattern matches a file only.
|
|
*/
|
|
FileOperationPatternKind.file = 'file';
|
|
/**
|
|
* The pattern matches a folder only.
|
|
*/
|
|
FileOperationPatternKind.folder = 'folder';
|
|
})(FileOperationPatternKind = exports.FileOperationPatternKind || (exports.FileOperationPatternKind = {}));
|
|
/**
|
|
* The will create files request is sent from the client to the server before files are actually
|
|
* created as long as the creation is triggered from within the client.
|
|
*
|
|
* The request can return a `WorkspaceEdit` which will be applied to workspace before the
|
|
* files are created. Hence the `WorkspaceEdit` can not manipulate the content of the file
|
|
* to be created.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var WillCreateFilesRequest;
|
|
(function (WillCreateFilesRequest) {
|
|
WillCreateFilesRequest.method = 'workspace/willCreateFiles';
|
|
WillCreateFilesRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
WillCreateFilesRequest.type = new messages_1.ProtocolRequestType(WillCreateFilesRequest.method);
|
|
})(WillCreateFilesRequest = exports.WillCreateFilesRequest || (exports.WillCreateFilesRequest = {}));
|
|
/**
|
|
* The did create files notification is sent from the client to the server when
|
|
* files were created from within the client.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var DidCreateFilesNotification;
|
|
(function (DidCreateFilesNotification) {
|
|
DidCreateFilesNotification.method = 'workspace/didCreateFiles';
|
|
DidCreateFilesNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidCreateFilesNotification.type = new messages_1.ProtocolNotificationType(DidCreateFilesNotification.method);
|
|
})(DidCreateFilesNotification = exports.DidCreateFilesNotification || (exports.DidCreateFilesNotification = {}));
|
|
/**
|
|
* The will rename files request is sent from the client to the server before files are actually
|
|
* renamed as long as the rename is triggered from within the client.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var WillRenameFilesRequest;
|
|
(function (WillRenameFilesRequest) {
|
|
WillRenameFilesRequest.method = 'workspace/willRenameFiles';
|
|
WillRenameFilesRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
WillRenameFilesRequest.type = new messages_1.ProtocolRequestType(WillRenameFilesRequest.method);
|
|
})(WillRenameFilesRequest = exports.WillRenameFilesRequest || (exports.WillRenameFilesRequest = {}));
|
|
/**
|
|
* The did rename files notification is sent from the client to the server when
|
|
* files were renamed from within the client.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var DidRenameFilesNotification;
|
|
(function (DidRenameFilesNotification) {
|
|
DidRenameFilesNotification.method = 'workspace/didRenameFiles';
|
|
DidRenameFilesNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidRenameFilesNotification.type = new messages_1.ProtocolNotificationType(DidRenameFilesNotification.method);
|
|
})(DidRenameFilesNotification = exports.DidRenameFilesNotification || (exports.DidRenameFilesNotification = {}));
|
|
/**
|
|
* The will delete files request is sent from the client to the server before files are actually
|
|
* deleted as long as the deletion is triggered from within the client.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var DidDeleteFilesNotification;
|
|
(function (DidDeleteFilesNotification) {
|
|
DidDeleteFilesNotification.method = 'workspace/didDeleteFiles';
|
|
DidDeleteFilesNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidDeleteFilesNotification.type = new messages_1.ProtocolNotificationType(DidDeleteFilesNotification.method);
|
|
})(DidDeleteFilesNotification = exports.DidDeleteFilesNotification || (exports.DidDeleteFilesNotification = {}));
|
|
/**
|
|
* The did delete files notification is sent from the client to the server when
|
|
* files were deleted from within the client.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var WillDeleteFilesRequest;
|
|
(function (WillDeleteFilesRequest) {
|
|
WillDeleteFilesRequest.method = 'workspace/willDeleteFiles';
|
|
WillDeleteFilesRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
WillDeleteFilesRequest.type = new messages_1.ProtocolRequestType(WillDeleteFilesRequest.method);
|
|
})(WillDeleteFilesRequest = exports.WillDeleteFilesRequest || (exports.WillDeleteFilesRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1203:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.FoldingRangeRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A request to provide folding ranges in a document. The request's
|
|
* parameter is of type {@link FoldingRangeParams}, the
|
|
* response is of type {@link FoldingRangeList} or a Thenable
|
|
* that resolves to such.
|
|
*/
|
|
var FoldingRangeRequest;
|
|
(function (FoldingRangeRequest) {
|
|
FoldingRangeRequest.method = 'textDocument/foldingRange';
|
|
FoldingRangeRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
FoldingRangeRequest.type = new messages_1.ProtocolRequestType(FoldingRangeRequest.method);
|
|
})(FoldingRangeRequest = exports.FoldingRangeRequest || (exports.FoldingRangeRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7287:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.ImplementationRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
// @ts-ignore: to avoid inlining LocationLink as dynamic import
|
|
let __noDynamicImport;
|
|
/**
|
|
* A request to resolve the implementation locations of a symbol at a given text
|
|
* document position. The request's parameter is of type [TextDocumentPositionParams]
|
|
* (#TextDocumentPositionParams) the response is of type {@link Definition} or a
|
|
* Thenable that resolves to such.
|
|
*/
|
|
var ImplementationRequest;
|
|
(function (ImplementationRequest) {
|
|
ImplementationRequest.method = 'textDocument/implementation';
|
|
ImplementationRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
ImplementationRequest.type = new messages_1.ProtocolRequestType(ImplementationRequest.method);
|
|
})(ImplementationRequest = exports.ImplementationRequest || (exports.ImplementationRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9383:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.InlayHintRefreshRequest = exports.InlayHintResolveRequest = exports.InlayHintRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A request to provide inlay hints in a document. The request's parameter is of
|
|
* type {@link InlayHintsParams}, the response is of type
|
|
* {@link InlayHint InlayHint[]} or a Thenable that resolves to such.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var InlayHintRequest;
|
|
(function (InlayHintRequest) {
|
|
InlayHintRequest.method = 'textDocument/inlayHint';
|
|
InlayHintRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
InlayHintRequest.type = new messages_1.ProtocolRequestType(InlayHintRequest.method);
|
|
})(InlayHintRequest = exports.InlayHintRequest || (exports.InlayHintRequest = {}));
|
|
/**
|
|
* A request to resolve additional properties for an inlay hint.
|
|
* The request's parameter is of type {@link InlayHint}, the response is
|
|
* of type {@link InlayHint} or a Thenable that resolves to such.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var InlayHintResolveRequest;
|
|
(function (InlayHintResolveRequest) {
|
|
InlayHintResolveRequest.method = 'inlayHint/resolve';
|
|
InlayHintResolveRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
InlayHintResolveRequest.type = new messages_1.ProtocolRequestType(InlayHintResolveRequest.method);
|
|
})(InlayHintResolveRequest = exports.InlayHintResolveRequest || (exports.InlayHintResolveRequest = {}));
|
|
/**
|
|
* @since 3.17.0
|
|
*/
|
|
var InlayHintRefreshRequest;
|
|
(function (InlayHintRefreshRequest) {
|
|
InlayHintRefreshRequest.method = `workspace/inlayHint/refresh`;
|
|
InlayHintRefreshRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
InlayHintRefreshRequest.type = new messages_1.ProtocolRequestType0(InlayHintRefreshRequest.method);
|
|
})(InlayHintRefreshRequest = exports.InlayHintRefreshRequest || (exports.InlayHintRefreshRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3491:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.InlineValueRefreshRequest = exports.InlineValueRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A request to provide inline values in a document. The request's parameter is of
|
|
* type {@link InlineValueParams}, the response is of type
|
|
* {@link InlineValue InlineValue[]} or a Thenable that resolves to such.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var InlineValueRequest;
|
|
(function (InlineValueRequest) {
|
|
InlineValueRequest.method = 'textDocument/inlineValue';
|
|
InlineValueRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
InlineValueRequest.type = new messages_1.ProtocolRequestType(InlineValueRequest.method);
|
|
})(InlineValueRequest = exports.InlineValueRequest || (exports.InlineValueRequest = {}));
|
|
/**
|
|
* @since 3.17.0
|
|
*/
|
|
var InlineValueRefreshRequest;
|
|
(function (InlineValueRefreshRequest) {
|
|
InlineValueRefreshRequest.method = `workspace/inlineValue/refresh`;
|
|
InlineValueRefreshRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
InlineValueRefreshRequest.type = new messages_1.ProtocolRequestType0(InlineValueRefreshRequest.method);
|
|
})(InlineValueRefreshRequest = exports.InlineValueRefreshRequest || (exports.InlineValueRefreshRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1815:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.WorkspaceSymbolRequest = exports.CodeActionResolveRequest = exports.CodeActionRequest = exports.DocumentSymbolRequest = exports.DocumentHighlightRequest = exports.ReferencesRequest = exports.DefinitionRequest = exports.SignatureHelpRequest = exports.SignatureHelpTriggerKind = exports.HoverRequest = exports.CompletionResolveRequest = exports.CompletionRequest = exports.CompletionTriggerKind = exports.PublishDiagnosticsNotification = exports.WatchKind = exports.RelativePattern = exports.FileChangeType = exports.DidChangeWatchedFilesNotification = exports.WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentNotification = exports.TextDocumentSaveReason = exports.DidSaveTextDocumentNotification = exports.DidCloseTextDocumentNotification = exports.DidChangeTextDocumentNotification = exports.TextDocumentContentChangeEvent = exports.DidOpenTextDocumentNotification = exports.TextDocumentSyncKind = exports.TelemetryEventNotification = exports.LogMessageNotification = exports.ShowMessageRequest = exports.ShowMessageNotification = exports.MessageType = exports.DidChangeConfigurationNotification = exports.ExitNotification = exports.ShutdownRequest = exports.InitializedNotification = exports.InitializeErrorCodes = exports.InitializeRequest = exports.WorkDoneProgressOptions = exports.TextDocumentRegistrationOptions = exports.StaticRegistrationOptions = exports.PositionEncodingKind = exports.FailureHandlingKind = exports.ResourceOperationKind = exports.UnregistrationRequest = exports.RegistrationRequest = exports.DocumentSelector = exports.NotebookCellTextDocumentFilter = exports.NotebookDocumentFilter = exports.TextDocumentFilter = void 0;
|
|
exports.TypeHierarchySubtypesRequest = exports.TypeHierarchyPrepareRequest = exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.WillRenameFilesRequest = exports.DidRenameFilesNotification = exports.WillCreateFilesRequest = exports.DidCreateFilesNotification = exports.FileOperationPatternKind = exports.LinkedEditingRangeRequest = exports.ShowDocumentRequest = exports.SemanticTokensRegistrationType = exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.TokenFormat = exports.CallHierarchyPrepareRequest = exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = exports.SelectionRangeRequest = exports.DeclarationRequest = exports.FoldingRangeRequest = exports.ColorPresentationRequest = exports.DocumentColorRequest = exports.ConfigurationRequest = exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = exports.TypeDefinitionRequest = exports.ImplementationRequest = exports.ApplyWorkspaceEditRequest = exports.ExecuteCommandRequest = exports.PrepareRenameRequest = exports.RenameRequest = exports.PrepareSupportDefaultBehavior = exports.DocumentOnTypeFormattingRequest = exports.DocumentRangeFormattingRequest = exports.DocumentFormattingRequest = exports.DocumentLinkResolveRequest = exports.DocumentLinkRequest = exports.CodeLensRefreshRequest = exports.CodeLensResolveRequest = exports.CodeLensRequest = exports.WorkspaceSymbolResolveRequest = void 0;
|
|
exports.DidCloseNotebookDocumentNotification = exports.DidSaveNotebookDocumentNotification = exports.DidChangeNotebookDocumentNotification = exports.NotebookCellArrayChange = exports.DidOpenNotebookDocumentNotification = exports.NotebookDocumentSyncRegistrationType = exports.NotebookDocument = exports.NotebookCell = exports.ExecutionSummary = exports.NotebookCellKind = exports.DiagnosticRefreshRequest = exports.WorkspaceDiagnosticRequest = exports.DocumentDiagnosticRequest = exports.DocumentDiagnosticReportKind = exports.DiagnosticServerCancellationData = exports.InlayHintRefreshRequest = exports.InlayHintResolveRequest = exports.InlayHintRequest = exports.InlineValueRefreshRequest = exports.InlineValueRequest = exports.TypeHierarchySupertypesRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
const vscode_languageserver_types_1 = __webpack_require__(7717);
|
|
const Is = __webpack_require__(8633);
|
|
const protocol_implementation_1 = __webpack_require__(7287);
|
|
Object.defineProperty(exports, "ImplementationRequest", ({ enumerable: true, get: function () { return protocol_implementation_1.ImplementationRequest; } }));
|
|
const protocol_typeDefinition_1 = __webpack_require__(9264);
|
|
Object.defineProperty(exports, "TypeDefinitionRequest", ({ enumerable: true, get: function () { return protocol_typeDefinition_1.TypeDefinitionRequest; } }));
|
|
const protocol_workspaceFolder_1 = __webpack_require__(6860);
|
|
Object.defineProperty(exports, "WorkspaceFoldersRequest", ({ enumerable: true, get: function () { return protocol_workspaceFolder_1.WorkspaceFoldersRequest; } }));
|
|
Object.defineProperty(exports, "DidChangeWorkspaceFoldersNotification", ({ enumerable: true, get: function () { return protocol_workspaceFolder_1.DidChangeWorkspaceFoldersNotification; } }));
|
|
const protocol_configuration_1 = __webpack_require__(7639);
|
|
Object.defineProperty(exports, "ConfigurationRequest", ({ enumerable: true, get: function () { return protocol_configuration_1.ConfigurationRequest; } }));
|
|
const protocol_colorProvider_1 = __webpack_require__(3747);
|
|
Object.defineProperty(exports, "DocumentColorRequest", ({ enumerable: true, get: function () { return protocol_colorProvider_1.DocumentColorRequest; } }));
|
|
Object.defineProperty(exports, "ColorPresentationRequest", ({ enumerable: true, get: function () { return protocol_colorProvider_1.ColorPresentationRequest; } }));
|
|
const protocol_foldingRange_1 = __webpack_require__(1203);
|
|
Object.defineProperty(exports, "FoldingRangeRequest", ({ enumerable: true, get: function () { return protocol_foldingRange_1.FoldingRangeRequest; } }));
|
|
const protocol_declaration_1 = __webpack_require__(5581);
|
|
Object.defineProperty(exports, "DeclarationRequest", ({ enumerable: true, get: function () { return protocol_declaration_1.DeclarationRequest; } }));
|
|
const protocol_selectionRange_1 = __webpack_require__(1530);
|
|
Object.defineProperty(exports, "SelectionRangeRequest", ({ enumerable: true, get: function () { return protocol_selectionRange_1.SelectionRangeRequest; } }));
|
|
const protocol_progress_1 = __webpack_require__(4166);
|
|
Object.defineProperty(exports, "WorkDoneProgress", ({ enumerable: true, get: function () { return protocol_progress_1.WorkDoneProgress; } }));
|
|
Object.defineProperty(exports, "WorkDoneProgressCreateRequest", ({ enumerable: true, get: function () { return protocol_progress_1.WorkDoneProgressCreateRequest; } }));
|
|
Object.defineProperty(exports, "WorkDoneProgressCancelNotification", ({ enumerable: true, get: function () { return protocol_progress_1.WorkDoneProgressCancelNotification; } }));
|
|
const protocol_callHierarchy_1 = __webpack_require__(7602);
|
|
Object.defineProperty(exports, "CallHierarchyIncomingCallsRequest", ({ enumerable: true, get: function () { return protocol_callHierarchy_1.CallHierarchyIncomingCallsRequest; } }));
|
|
Object.defineProperty(exports, "CallHierarchyOutgoingCallsRequest", ({ enumerable: true, get: function () { return protocol_callHierarchy_1.CallHierarchyOutgoingCallsRequest; } }));
|
|
Object.defineProperty(exports, "CallHierarchyPrepareRequest", ({ enumerable: true, get: function () { return protocol_callHierarchy_1.CallHierarchyPrepareRequest; } }));
|
|
const protocol_semanticTokens_1 = __webpack_require__(2067);
|
|
Object.defineProperty(exports, "TokenFormat", ({ enumerable: true, get: function () { return protocol_semanticTokens_1.TokenFormat; } }));
|
|
Object.defineProperty(exports, "SemanticTokensRequest", ({ enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokensRequest; } }));
|
|
Object.defineProperty(exports, "SemanticTokensDeltaRequest", ({ enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokensDeltaRequest; } }));
|
|
Object.defineProperty(exports, "SemanticTokensRangeRequest", ({ enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokensRangeRequest; } }));
|
|
Object.defineProperty(exports, "SemanticTokensRefreshRequest", ({ enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokensRefreshRequest; } }));
|
|
Object.defineProperty(exports, "SemanticTokensRegistrationType", ({ enumerable: true, get: function () { return protocol_semanticTokens_1.SemanticTokensRegistrationType; } }));
|
|
const protocol_showDocument_1 = __webpack_require__(4333);
|
|
Object.defineProperty(exports, "ShowDocumentRequest", ({ enumerable: true, get: function () { return protocol_showDocument_1.ShowDocumentRequest; } }));
|
|
const protocol_linkedEditingRange_1 = __webpack_require__(2249);
|
|
Object.defineProperty(exports, "LinkedEditingRangeRequest", ({ enumerable: true, get: function () { return protocol_linkedEditingRange_1.LinkedEditingRangeRequest; } }));
|
|
const protocol_fileOperations_1 = __webpack_require__(4781);
|
|
Object.defineProperty(exports, "FileOperationPatternKind", ({ enumerable: true, get: function () { return protocol_fileOperations_1.FileOperationPatternKind; } }));
|
|
Object.defineProperty(exports, "DidCreateFilesNotification", ({ enumerable: true, get: function () { return protocol_fileOperations_1.DidCreateFilesNotification; } }));
|
|
Object.defineProperty(exports, "WillCreateFilesRequest", ({ enumerable: true, get: function () { return protocol_fileOperations_1.WillCreateFilesRequest; } }));
|
|
Object.defineProperty(exports, "DidRenameFilesNotification", ({ enumerable: true, get: function () { return protocol_fileOperations_1.DidRenameFilesNotification; } }));
|
|
Object.defineProperty(exports, "WillRenameFilesRequest", ({ enumerable: true, get: function () { return protocol_fileOperations_1.WillRenameFilesRequest; } }));
|
|
Object.defineProperty(exports, "DidDeleteFilesNotification", ({ enumerable: true, get: function () { return protocol_fileOperations_1.DidDeleteFilesNotification; } }));
|
|
Object.defineProperty(exports, "WillDeleteFilesRequest", ({ enumerable: true, get: function () { return protocol_fileOperations_1.WillDeleteFilesRequest; } }));
|
|
const protocol_moniker_1 = __webpack_require__(7684);
|
|
Object.defineProperty(exports, "UniquenessLevel", ({ enumerable: true, get: function () { return protocol_moniker_1.UniquenessLevel; } }));
|
|
Object.defineProperty(exports, "MonikerKind", ({ enumerable: true, get: function () { return protocol_moniker_1.MonikerKind; } }));
|
|
Object.defineProperty(exports, "MonikerRequest", ({ enumerable: true, get: function () { return protocol_moniker_1.MonikerRequest; } }));
|
|
const protocol_typeHierarchy_1 = __webpack_require__(7062);
|
|
Object.defineProperty(exports, "TypeHierarchyPrepareRequest", ({ enumerable: true, get: function () { return protocol_typeHierarchy_1.TypeHierarchyPrepareRequest; } }));
|
|
Object.defineProperty(exports, "TypeHierarchySubtypesRequest", ({ enumerable: true, get: function () { return protocol_typeHierarchy_1.TypeHierarchySubtypesRequest; } }));
|
|
Object.defineProperty(exports, "TypeHierarchySupertypesRequest", ({ enumerable: true, get: function () { return protocol_typeHierarchy_1.TypeHierarchySupertypesRequest; } }));
|
|
const protocol_inlineValue_1 = __webpack_require__(3491);
|
|
Object.defineProperty(exports, "InlineValueRequest", ({ enumerable: true, get: function () { return protocol_inlineValue_1.InlineValueRequest; } }));
|
|
Object.defineProperty(exports, "InlineValueRefreshRequest", ({ enumerable: true, get: function () { return protocol_inlineValue_1.InlineValueRefreshRequest; } }));
|
|
const protocol_inlayHint_1 = __webpack_require__(9383);
|
|
Object.defineProperty(exports, "InlayHintRequest", ({ enumerable: true, get: function () { return protocol_inlayHint_1.InlayHintRequest; } }));
|
|
Object.defineProperty(exports, "InlayHintResolveRequest", ({ enumerable: true, get: function () { return protocol_inlayHint_1.InlayHintResolveRequest; } }));
|
|
Object.defineProperty(exports, "InlayHintRefreshRequest", ({ enumerable: true, get: function () { return protocol_inlayHint_1.InlayHintRefreshRequest; } }));
|
|
const protocol_diagnostic_1 = __webpack_require__(1494);
|
|
Object.defineProperty(exports, "DiagnosticServerCancellationData", ({ enumerable: true, get: function () { return protocol_diagnostic_1.DiagnosticServerCancellationData; } }));
|
|
Object.defineProperty(exports, "DocumentDiagnosticReportKind", ({ enumerable: true, get: function () { return protocol_diagnostic_1.DocumentDiagnosticReportKind; } }));
|
|
Object.defineProperty(exports, "DocumentDiagnosticRequest", ({ enumerable: true, get: function () { return protocol_diagnostic_1.DocumentDiagnosticRequest; } }));
|
|
Object.defineProperty(exports, "WorkspaceDiagnosticRequest", ({ enumerable: true, get: function () { return protocol_diagnostic_1.WorkspaceDiagnosticRequest; } }));
|
|
Object.defineProperty(exports, "DiagnosticRefreshRequest", ({ enumerable: true, get: function () { return protocol_diagnostic_1.DiagnosticRefreshRequest; } }));
|
|
const protocol_notebook_1 = __webpack_require__(4792);
|
|
Object.defineProperty(exports, "NotebookCellKind", ({ enumerable: true, get: function () { return protocol_notebook_1.NotebookCellKind; } }));
|
|
Object.defineProperty(exports, "ExecutionSummary", ({ enumerable: true, get: function () { return protocol_notebook_1.ExecutionSummary; } }));
|
|
Object.defineProperty(exports, "NotebookCell", ({ enumerable: true, get: function () { return protocol_notebook_1.NotebookCell; } }));
|
|
Object.defineProperty(exports, "NotebookDocument", ({ enumerable: true, get: function () { return protocol_notebook_1.NotebookDocument; } }));
|
|
Object.defineProperty(exports, "NotebookDocumentSyncRegistrationType", ({ enumerable: true, get: function () { return protocol_notebook_1.NotebookDocumentSyncRegistrationType; } }));
|
|
Object.defineProperty(exports, "DidOpenNotebookDocumentNotification", ({ enumerable: true, get: function () { return protocol_notebook_1.DidOpenNotebookDocumentNotification; } }));
|
|
Object.defineProperty(exports, "NotebookCellArrayChange", ({ enumerable: true, get: function () { return protocol_notebook_1.NotebookCellArrayChange; } }));
|
|
Object.defineProperty(exports, "DidChangeNotebookDocumentNotification", ({ enumerable: true, get: function () { return protocol_notebook_1.DidChangeNotebookDocumentNotification; } }));
|
|
Object.defineProperty(exports, "DidSaveNotebookDocumentNotification", ({ enumerable: true, get: function () { return protocol_notebook_1.DidSaveNotebookDocumentNotification; } }));
|
|
Object.defineProperty(exports, "DidCloseNotebookDocumentNotification", ({ enumerable: true, get: function () { return protocol_notebook_1.DidCloseNotebookDocumentNotification; } }));
|
|
// @ts-ignore: to avoid inlining LocationLink as dynamic import
|
|
let __noDynamicImport;
|
|
/**
|
|
* The TextDocumentFilter namespace provides helper functions to work with
|
|
* {@link TextDocumentFilter} literals.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var TextDocumentFilter;
|
|
(function (TextDocumentFilter) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.string(candidate.language) || Is.string(candidate.scheme) || Is.string(candidate.pattern);
|
|
}
|
|
TextDocumentFilter.is = is;
|
|
})(TextDocumentFilter = exports.TextDocumentFilter || (exports.TextDocumentFilter = {}));
|
|
/**
|
|
* The NotebookDocumentFilter namespace provides helper functions to work with
|
|
* {@link NotebookDocumentFilter} literals.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var NotebookDocumentFilter;
|
|
(function (NotebookDocumentFilter) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.objectLiteral(candidate) && (Is.string(candidate.notebookType) || Is.string(candidate.scheme) || Is.string(candidate.pattern));
|
|
}
|
|
NotebookDocumentFilter.is = is;
|
|
})(NotebookDocumentFilter = exports.NotebookDocumentFilter || (exports.NotebookDocumentFilter = {}));
|
|
/**
|
|
* The NotebookCellTextDocumentFilter namespace provides helper functions to work with
|
|
* {@link NotebookCellTextDocumentFilter} literals.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var NotebookCellTextDocumentFilter;
|
|
(function (NotebookCellTextDocumentFilter) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.objectLiteral(candidate)
|
|
&& (Is.string(candidate.notebook) || NotebookDocumentFilter.is(candidate.notebook))
|
|
&& (candidate.language === undefined || Is.string(candidate.language));
|
|
}
|
|
NotebookCellTextDocumentFilter.is = is;
|
|
})(NotebookCellTextDocumentFilter = exports.NotebookCellTextDocumentFilter || (exports.NotebookCellTextDocumentFilter = {}));
|
|
/**
|
|
* The DocumentSelector namespace provides helper functions to work with
|
|
* {@link DocumentSelector}s.
|
|
*/
|
|
var DocumentSelector;
|
|
(function (DocumentSelector) {
|
|
function is(value) {
|
|
if (!Array.isArray(value)) {
|
|
return false;
|
|
}
|
|
for (let elem of value) {
|
|
if (!Is.string(elem) && !TextDocumentFilter.is(elem) && !NotebookCellTextDocumentFilter.is(elem)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
DocumentSelector.is = is;
|
|
})(DocumentSelector = exports.DocumentSelector || (exports.DocumentSelector = {}));
|
|
/**
|
|
* The `client/registerCapability` request is sent from the server to the client to register a new capability
|
|
* handler on the client side.
|
|
*/
|
|
var RegistrationRequest;
|
|
(function (RegistrationRequest) {
|
|
RegistrationRequest.method = 'client/registerCapability';
|
|
RegistrationRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
RegistrationRequest.type = new messages_1.ProtocolRequestType(RegistrationRequest.method);
|
|
})(RegistrationRequest = exports.RegistrationRequest || (exports.RegistrationRequest = {}));
|
|
/**
|
|
* The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability
|
|
* handler on the client side.
|
|
*/
|
|
var UnregistrationRequest;
|
|
(function (UnregistrationRequest) {
|
|
UnregistrationRequest.method = 'client/unregisterCapability';
|
|
UnregistrationRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
UnregistrationRequest.type = new messages_1.ProtocolRequestType(UnregistrationRequest.method);
|
|
})(UnregistrationRequest = exports.UnregistrationRequest || (exports.UnregistrationRequest = {}));
|
|
var ResourceOperationKind;
|
|
(function (ResourceOperationKind) {
|
|
/**
|
|
* Supports creating new files and folders.
|
|
*/
|
|
ResourceOperationKind.Create = 'create';
|
|
/**
|
|
* Supports renaming existing files and folders.
|
|
*/
|
|
ResourceOperationKind.Rename = 'rename';
|
|
/**
|
|
* Supports deleting existing files and folders.
|
|
*/
|
|
ResourceOperationKind.Delete = 'delete';
|
|
})(ResourceOperationKind = exports.ResourceOperationKind || (exports.ResourceOperationKind = {}));
|
|
var FailureHandlingKind;
|
|
(function (FailureHandlingKind) {
|
|
/**
|
|
* Applying the workspace change is simply aborted if one of the changes provided
|
|
* fails. All operations executed before the failing operation stay executed.
|
|
*/
|
|
FailureHandlingKind.Abort = 'abort';
|
|
/**
|
|
* All operations are executed transactional. That means they either all
|
|
* succeed or no changes at all are applied to the workspace.
|
|
*/
|
|
FailureHandlingKind.Transactional = 'transactional';
|
|
/**
|
|
* If the workspace edit contains only textual file changes they are executed transactional.
|
|
* If resource changes (create, rename or delete file) are part of the change the failure
|
|
* handling strategy is abort.
|
|
*/
|
|
FailureHandlingKind.TextOnlyTransactional = 'textOnlyTransactional';
|
|
/**
|
|
* The client tries to undo the operations already executed. But there is no
|
|
* guarantee that this is succeeding.
|
|
*/
|
|
FailureHandlingKind.Undo = 'undo';
|
|
})(FailureHandlingKind = exports.FailureHandlingKind || (exports.FailureHandlingKind = {}));
|
|
/**
|
|
* A set of predefined position encoding kinds.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var PositionEncodingKind;
|
|
(function (PositionEncodingKind) {
|
|
/**
|
|
* Character offsets count UTF-8 code units (e.g. bytes).
|
|
*/
|
|
PositionEncodingKind.UTF8 = 'utf-8';
|
|
/**
|
|
* Character offsets count UTF-16 code units.
|
|
*
|
|
* This is the default and must always be supported
|
|
* by servers
|
|
*/
|
|
PositionEncodingKind.UTF16 = 'utf-16';
|
|
/**
|
|
* Character offsets count UTF-32 code units.
|
|
*
|
|
* Implementation note: these are the same as Unicode codepoints,
|
|
* so this `PositionEncodingKind` may also be used for an
|
|
* encoding-agnostic representation of character offsets.
|
|
*/
|
|
PositionEncodingKind.UTF32 = 'utf-32';
|
|
})(PositionEncodingKind = exports.PositionEncodingKind || (exports.PositionEncodingKind = {}));
|
|
/**
|
|
* The StaticRegistrationOptions namespace provides helper functions to work with
|
|
* {@link StaticRegistrationOptions} literals.
|
|
*/
|
|
var StaticRegistrationOptions;
|
|
(function (StaticRegistrationOptions) {
|
|
function hasId(value) {
|
|
const candidate = value;
|
|
return candidate && Is.string(candidate.id) && candidate.id.length > 0;
|
|
}
|
|
StaticRegistrationOptions.hasId = hasId;
|
|
})(StaticRegistrationOptions = exports.StaticRegistrationOptions || (exports.StaticRegistrationOptions = {}));
|
|
/**
|
|
* The TextDocumentRegistrationOptions namespace provides helper functions to work with
|
|
* {@link TextDocumentRegistrationOptions} literals.
|
|
*/
|
|
var TextDocumentRegistrationOptions;
|
|
(function (TextDocumentRegistrationOptions) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return candidate && (candidate.documentSelector === null || DocumentSelector.is(candidate.documentSelector));
|
|
}
|
|
TextDocumentRegistrationOptions.is = is;
|
|
})(TextDocumentRegistrationOptions = exports.TextDocumentRegistrationOptions || (exports.TextDocumentRegistrationOptions = {}));
|
|
/**
|
|
* The WorkDoneProgressOptions namespace provides helper functions to work with
|
|
* {@link WorkDoneProgressOptions} literals.
|
|
*/
|
|
var WorkDoneProgressOptions;
|
|
(function (WorkDoneProgressOptions) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.objectLiteral(candidate) && (candidate.workDoneProgress === undefined || Is.boolean(candidate.workDoneProgress));
|
|
}
|
|
WorkDoneProgressOptions.is = is;
|
|
function hasWorkDoneProgress(value) {
|
|
const candidate = value;
|
|
return candidate && Is.boolean(candidate.workDoneProgress);
|
|
}
|
|
WorkDoneProgressOptions.hasWorkDoneProgress = hasWorkDoneProgress;
|
|
})(WorkDoneProgressOptions = exports.WorkDoneProgressOptions || (exports.WorkDoneProgressOptions = {}));
|
|
/**
|
|
* The initialize request is sent from the client to the server.
|
|
* It is sent once as the request after starting up the server.
|
|
* The requests parameter is of type {@link InitializeParams}
|
|
* the response if of type {@link InitializeResult} of a Thenable that
|
|
* resolves to such.
|
|
*/
|
|
var InitializeRequest;
|
|
(function (InitializeRequest) {
|
|
InitializeRequest.method = 'initialize';
|
|
InitializeRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
InitializeRequest.type = new messages_1.ProtocolRequestType(InitializeRequest.method);
|
|
})(InitializeRequest = exports.InitializeRequest || (exports.InitializeRequest = {}));
|
|
/**
|
|
* Known error codes for an `InitializeErrorCodes`;
|
|
*/
|
|
var InitializeErrorCodes;
|
|
(function (InitializeErrorCodes) {
|
|
/**
|
|
* If the protocol version provided by the client can't be handled by the server.
|
|
*
|
|
* @deprecated This initialize error got replaced by client capabilities. There is
|
|
* no version handshake in version 3.0x
|
|
*/
|
|
InitializeErrorCodes.unknownProtocolVersion = 1;
|
|
})(InitializeErrorCodes = exports.InitializeErrorCodes || (exports.InitializeErrorCodes = {}));
|
|
/**
|
|
* The initialized notification is sent from the client to the
|
|
* server after the client is fully initialized and the server
|
|
* is allowed to send requests from the server to the client.
|
|
*/
|
|
var InitializedNotification;
|
|
(function (InitializedNotification) {
|
|
InitializedNotification.method = 'initialized';
|
|
InitializedNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
InitializedNotification.type = new messages_1.ProtocolNotificationType(InitializedNotification.method);
|
|
})(InitializedNotification = exports.InitializedNotification || (exports.InitializedNotification = {}));
|
|
//---- Shutdown Method ----
|
|
/**
|
|
* A shutdown request is sent from the client to the server.
|
|
* It is sent once when the client decides to shutdown the
|
|
* server. The only notification that is sent after a shutdown request
|
|
* is the exit event.
|
|
*/
|
|
var ShutdownRequest;
|
|
(function (ShutdownRequest) {
|
|
ShutdownRequest.method = 'shutdown';
|
|
ShutdownRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
ShutdownRequest.type = new messages_1.ProtocolRequestType0(ShutdownRequest.method);
|
|
})(ShutdownRequest = exports.ShutdownRequest || (exports.ShutdownRequest = {}));
|
|
//---- Exit Notification ----
|
|
/**
|
|
* The exit event is sent from the client to the server to
|
|
* ask the server to exit its process.
|
|
*/
|
|
var ExitNotification;
|
|
(function (ExitNotification) {
|
|
ExitNotification.method = 'exit';
|
|
ExitNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
ExitNotification.type = new messages_1.ProtocolNotificationType0(ExitNotification.method);
|
|
})(ExitNotification = exports.ExitNotification || (exports.ExitNotification = {}));
|
|
/**
|
|
* The configuration change notification is sent from the client to the server
|
|
* when the client's configuration has changed. The notification contains
|
|
* the changed configuration as defined by the language client.
|
|
*/
|
|
var DidChangeConfigurationNotification;
|
|
(function (DidChangeConfigurationNotification) {
|
|
DidChangeConfigurationNotification.method = 'workspace/didChangeConfiguration';
|
|
DidChangeConfigurationNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidChangeConfigurationNotification.type = new messages_1.ProtocolNotificationType(DidChangeConfigurationNotification.method);
|
|
})(DidChangeConfigurationNotification = exports.DidChangeConfigurationNotification || (exports.DidChangeConfigurationNotification = {}));
|
|
//---- Message show and log notifications ----
|
|
/**
|
|
* The message type
|
|
*/
|
|
var MessageType;
|
|
(function (MessageType) {
|
|
/**
|
|
* An error message.
|
|
*/
|
|
MessageType.Error = 1;
|
|
/**
|
|
* A warning message.
|
|
*/
|
|
MessageType.Warning = 2;
|
|
/**
|
|
* An information message.
|
|
*/
|
|
MessageType.Info = 3;
|
|
/**
|
|
* A log message.
|
|
*/
|
|
MessageType.Log = 4;
|
|
})(MessageType = exports.MessageType || (exports.MessageType = {}));
|
|
/**
|
|
* The show message notification is sent from a server to a client to ask
|
|
* the client to display a particular message in the user interface.
|
|
*/
|
|
var ShowMessageNotification;
|
|
(function (ShowMessageNotification) {
|
|
ShowMessageNotification.method = 'window/showMessage';
|
|
ShowMessageNotification.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
ShowMessageNotification.type = new messages_1.ProtocolNotificationType(ShowMessageNotification.method);
|
|
})(ShowMessageNotification = exports.ShowMessageNotification || (exports.ShowMessageNotification = {}));
|
|
/**
|
|
* The show message request is sent from the server to the client to show a message
|
|
* and a set of options actions to the user.
|
|
*/
|
|
var ShowMessageRequest;
|
|
(function (ShowMessageRequest) {
|
|
ShowMessageRequest.method = 'window/showMessageRequest';
|
|
ShowMessageRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
ShowMessageRequest.type = new messages_1.ProtocolRequestType(ShowMessageRequest.method);
|
|
})(ShowMessageRequest = exports.ShowMessageRequest || (exports.ShowMessageRequest = {}));
|
|
/**
|
|
* The log message notification is sent from the server to the client to ask
|
|
* the client to log a particular message.
|
|
*/
|
|
var LogMessageNotification;
|
|
(function (LogMessageNotification) {
|
|
LogMessageNotification.method = 'window/logMessage';
|
|
LogMessageNotification.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
LogMessageNotification.type = new messages_1.ProtocolNotificationType(LogMessageNotification.method);
|
|
})(LogMessageNotification = exports.LogMessageNotification || (exports.LogMessageNotification = {}));
|
|
//---- Telemetry notification
|
|
/**
|
|
* The telemetry event notification is sent from the server to the client to ask
|
|
* the client to log telemetry data.
|
|
*/
|
|
var TelemetryEventNotification;
|
|
(function (TelemetryEventNotification) {
|
|
TelemetryEventNotification.method = 'telemetry/event';
|
|
TelemetryEventNotification.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
TelemetryEventNotification.type = new messages_1.ProtocolNotificationType(TelemetryEventNotification.method);
|
|
})(TelemetryEventNotification = exports.TelemetryEventNotification || (exports.TelemetryEventNotification = {}));
|
|
/**
|
|
* Defines how the host (editor) should sync
|
|
* document changes to the language server.
|
|
*/
|
|
var TextDocumentSyncKind;
|
|
(function (TextDocumentSyncKind) {
|
|
/**
|
|
* Documents should not be synced at all.
|
|
*/
|
|
TextDocumentSyncKind.None = 0;
|
|
/**
|
|
* Documents are synced by always sending the full content
|
|
* of the document.
|
|
*/
|
|
TextDocumentSyncKind.Full = 1;
|
|
/**
|
|
* Documents are synced by sending the full content on open.
|
|
* After that only incremental updates to the document are
|
|
* send.
|
|
*/
|
|
TextDocumentSyncKind.Incremental = 2;
|
|
})(TextDocumentSyncKind = exports.TextDocumentSyncKind || (exports.TextDocumentSyncKind = {}));
|
|
/**
|
|
* The document open notification is sent from the client to the server to signal
|
|
* newly opened text documents. The document's truth is now managed by the client
|
|
* and the server must not try to read the document's truth using the document's
|
|
* uri. Open in this sense means it is managed by the client. It doesn't necessarily
|
|
* mean that its content is presented in an editor. An open notification must not
|
|
* be sent more than once without a corresponding close notification send before.
|
|
* This means open and close notification must be balanced and the max open count
|
|
* is one.
|
|
*/
|
|
var DidOpenTextDocumentNotification;
|
|
(function (DidOpenTextDocumentNotification) {
|
|
DidOpenTextDocumentNotification.method = 'textDocument/didOpen';
|
|
DidOpenTextDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidOpenTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification.method);
|
|
})(DidOpenTextDocumentNotification = exports.DidOpenTextDocumentNotification || (exports.DidOpenTextDocumentNotification = {}));
|
|
var TextDocumentContentChangeEvent;
|
|
(function (TextDocumentContentChangeEvent) {
|
|
/**
|
|
* Checks whether the information describes a delta event.
|
|
*/
|
|
function isIncremental(event) {
|
|
let candidate = event;
|
|
return candidate !== undefined && candidate !== null &&
|
|
typeof candidate.text === 'string' && candidate.range !== undefined &&
|
|
(candidate.rangeLength === undefined || typeof candidate.rangeLength === 'number');
|
|
}
|
|
TextDocumentContentChangeEvent.isIncremental = isIncremental;
|
|
/**
|
|
* Checks whether the information describes a full replacement event.
|
|
*/
|
|
function isFull(event) {
|
|
let candidate = event;
|
|
return candidate !== undefined && candidate !== null &&
|
|
typeof candidate.text === 'string' && candidate.range === undefined && candidate.rangeLength === undefined;
|
|
}
|
|
TextDocumentContentChangeEvent.isFull = isFull;
|
|
})(TextDocumentContentChangeEvent = exports.TextDocumentContentChangeEvent || (exports.TextDocumentContentChangeEvent = {}));
|
|
/**
|
|
* The document change notification is sent from the client to the server to signal
|
|
* changes to a text document.
|
|
*/
|
|
var DidChangeTextDocumentNotification;
|
|
(function (DidChangeTextDocumentNotification) {
|
|
DidChangeTextDocumentNotification.method = 'textDocument/didChange';
|
|
DidChangeTextDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidChangeTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidChangeTextDocumentNotification.method);
|
|
})(DidChangeTextDocumentNotification = exports.DidChangeTextDocumentNotification || (exports.DidChangeTextDocumentNotification = {}));
|
|
/**
|
|
* The document close notification is sent from the client to the server when
|
|
* the document got closed in the client. The document's truth now exists where
|
|
* the document's uri points to (e.g. if the document's uri is a file uri the
|
|
* truth now exists on disk). As with the open notification the close notification
|
|
* is about managing the document's content. Receiving a close notification
|
|
* doesn't mean that the document was open in an editor before. A close
|
|
* notification requires a previous open notification to be sent.
|
|
*/
|
|
var DidCloseTextDocumentNotification;
|
|
(function (DidCloseTextDocumentNotification) {
|
|
DidCloseTextDocumentNotification.method = 'textDocument/didClose';
|
|
DidCloseTextDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidCloseTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidCloseTextDocumentNotification.method);
|
|
})(DidCloseTextDocumentNotification = exports.DidCloseTextDocumentNotification || (exports.DidCloseTextDocumentNotification = {}));
|
|
/**
|
|
* The document save notification is sent from the client to the server when
|
|
* the document got saved in the client.
|
|
*/
|
|
var DidSaveTextDocumentNotification;
|
|
(function (DidSaveTextDocumentNotification) {
|
|
DidSaveTextDocumentNotification.method = 'textDocument/didSave';
|
|
DidSaveTextDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidSaveTextDocumentNotification.type = new messages_1.ProtocolNotificationType(DidSaveTextDocumentNotification.method);
|
|
})(DidSaveTextDocumentNotification = exports.DidSaveTextDocumentNotification || (exports.DidSaveTextDocumentNotification = {}));
|
|
/**
|
|
* Represents reasons why a text document is saved.
|
|
*/
|
|
var TextDocumentSaveReason;
|
|
(function (TextDocumentSaveReason) {
|
|
/**
|
|
* Manually triggered, e.g. by the user pressing save, by starting debugging,
|
|
* or by an API call.
|
|
*/
|
|
TextDocumentSaveReason.Manual = 1;
|
|
/**
|
|
* Automatic after a delay.
|
|
*/
|
|
TextDocumentSaveReason.AfterDelay = 2;
|
|
/**
|
|
* When the editor lost focus.
|
|
*/
|
|
TextDocumentSaveReason.FocusOut = 3;
|
|
})(TextDocumentSaveReason = exports.TextDocumentSaveReason || (exports.TextDocumentSaveReason = {}));
|
|
/**
|
|
* A document will save notification is sent from the client to the server before
|
|
* the document is actually saved.
|
|
*/
|
|
var WillSaveTextDocumentNotification;
|
|
(function (WillSaveTextDocumentNotification) {
|
|
WillSaveTextDocumentNotification.method = 'textDocument/willSave';
|
|
WillSaveTextDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
WillSaveTextDocumentNotification.type = new messages_1.ProtocolNotificationType(WillSaveTextDocumentNotification.method);
|
|
})(WillSaveTextDocumentNotification = exports.WillSaveTextDocumentNotification || (exports.WillSaveTextDocumentNotification = {}));
|
|
/**
|
|
* A document will save request is sent from the client to the server before
|
|
* the document is actually saved. The request can return an array of TextEdits
|
|
* which will be applied to the text document before it is saved. Please note that
|
|
* clients might drop results if computing the text edits took too long or if a
|
|
* server constantly fails on this request. This is done to keep the save fast and
|
|
* reliable.
|
|
*/
|
|
var WillSaveTextDocumentWaitUntilRequest;
|
|
(function (WillSaveTextDocumentWaitUntilRequest) {
|
|
WillSaveTextDocumentWaitUntilRequest.method = 'textDocument/willSaveWaitUntil';
|
|
WillSaveTextDocumentWaitUntilRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
WillSaveTextDocumentWaitUntilRequest.type = new messages_1.ProtocolRequestType(WillSaveTextDocumentWaitUntilRequest.method);
|
|
})(WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentWaitUntilRequest || (exports.WillSaveTextDocumentWaitUntilRequest = {}));
|
|
/**
|
|
* The watched files notification is sent from the client to the server when
|
|
* the client detects changes to file watched by the language client.
|
|
*/
|
|
var DidChangeWatchedFilesNotification;
|
|
(function (DidChangeWatchedFilesNotification) {
|
|
DidChangeWatchedFilesNotification.method = 'workspace/didChangeWatchedFiles';
|
|
DidChangeWatchedFilesNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidChangeWatchedFilesNotification.type = new messages_1.ProtocolNotificationType(DidChangeWatchedFilesNotification.method);
|
|
})(DidChangeWatchedFilesNotification = exports.DidChangeWatchedFilesNotification || (exports.DidChangeWatchedFilesNotification = {}));
|
|
/**
|
|
* The file event type
|
|
*/
|
|
var FileChangeType;
|
|
(function (FileChangeType) {
|
|
/**
|
|
* The file got created.
|
|
*/
|
|
FileChangeType.Created = 1;
|
|
/**
|
|
* The file got changed.
|
|
*/
|
|
FileChangeType.Changed = 2;
|
|
/**
|
|
* The file got deleted.
|
|
*/
|
|
FileChangeType.Deleted = 3;
|
|
})(FileChangeType = exports.FileChangeType || (exports.FileChangeType = {}));
|
|
var RelativePattern;
|
|
(function (RelativePattern) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.objectLiteral(candidate) && (vscode_languageserver_types_1.URI.is(candidate.baseUri) || vscode_languageserver_types_1.WorkspaceFolder.is(candidate.baseUri)) && Is.string(candidate.pattern);
|
|
}
|
|
RelativePattern.is = is;
|
|
})(RelativePattern = exports.RelativePattern || (exports.RelativePattern = {}));
|
|
var WatchKind;
|
|
(function (WatchKind) {
|
|
/**
|
|
* Interested in create events.
|
|
*/
|
|
WatchKind.Create = 1;
|
|
/**
|
|
* Interested in change events
|
|
*/
|
|
WatchKind.Change = 2;
|
|
/**
|
|
* Interested in delete events
|
|
*/
|
|
WatchKind.Delete = 4;
|
|
})(WatchKind = exports.WatchKind || (exports.WatchKind = {}));
|
|
/**
|
|
* Diagnostics notification are sent from the server to the client to signal
|
|
* results of validation runs.
|
|
*/
|
|
var PublishDiagnosticsNotification;
|
|
(function (PublishDiagnosticsNotification) {
|
|
PublishDiagnosticsNotification.method = 'textDocument/publishDiagnostics';
|
|
PublishDiagnosticsNotification.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
PublishDiagnosticsNotification.type = new messages_1.ProtocolNotificationType(PublishDiagnosticsNotification.method);
|
|
})(PublishDiagnosticsNotification = exports.PublishDiagnosticsNotification || (exports.PublishDiagnosticsNotification = {}));
|
|
/**
|
|
* How a completion was triggered
|
|
*/
|
|
var CompletionTriggerKind;
|
|
(function (CompletionTriggerKind) {
|
|
/**
|
|
* Completion was triggered by typing an identifier (24x7 code
|
|
* complete), manual invocation (e.g Ctrl+Space) or via API.
|
|
*/
|
|
CompletionTriggerKind.Invoked = 1;
|
|
/**
|
|
* Completion was triggered by a trigger character specified by
|
|
* the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
|
|
*/
|
|
CompletionTriggerKind.TriggerCharacter = 2;
|
|
/**
|
|
* Completion was re-triggered as current completion list is incomplete
|
|
*/
|
|
CompletionTriggerKind.TriggerForIncompleteCompletions = 3;
|
|
})(CompletionTriggerKind = exports.CompletionTriggerKind || (exports.CompletionTriggerKind = {}));
|
|
/**
|
|
* Request to request completion at a given text document position. The request's
|
|
* parameter is of type {@link TextDocumentPosition} the response
|
|
* is of type {@link CompletionItem CompletionItem[]} or {@link CompletionList}
|
|
* or a Thenable that resolves to such.
|
|
*
|
|
* The request can delay the computation of the {@link CompletionItem.detail `detail`}
|
|
* and {@link CompletionItem.documentation `documentation`} properties to the `completionItem/resolve`
|
|
* request. However, properties that are needed for the initial sorting and filtering, like `sortText`,
|
|
* `filterText`, `insertText`, and `textEdit`, must not be changed during resolve.
|
|
*/
|
|
var CompletionRequest;
|
|
(function (CompletionRequest) {
|
|
CompletionRequest.method = 'textDocument/completion';
|
|
CompletionRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
CompletionRequest.type = new messages_1.ProtocolRequestType(CompletionRequest.method);
|
|
})(CompletionRequest = exports.CompletionRequest || (exports.CompletionRequest = {}));
|
|
/**
|
|
* Request to resolve additional information for a given completion item.The request's
|
|
* parameter is of type {@link CompletionItem} the response
|
|
* is of type {@link CompletionItem} or a Thenable that resolves to such.
|
|
*/
|
|
var CompletionResolveRequest;
|
|
(function (CompletionResolveRequest) {
|
|
CompletionResolveRequest.method = 'completionItem/resolve';
|
|
CompletionResolveRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
CompletionResolveRequest.type = new messages_1.ProtocolRequestType(CompletionResolveRequest.method);
|
|
})(CompletionResolveRequest = exports.CompletionResolveRequest || (exports.CompletionResolveRequest = {}));
|
|
/**
|
|
* Request to request hover information at a given text document position. The request's
|
|
* parameter is of type {@link TextDocumentPosition} the response is of
|
|
* type {@link Hover} or a Thenable that resolves to such.
|
|
*/
|
|
var HoverRequest;
|
|
(function (HoverRequest) {
|
|
HoverRequest.method = 'textDocument/hover';
|
|
HoverRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
HoverRequest.type = new messages_1.ProtocolRequestType(HoverRequest.method);
|
|
})(HoverRequest = exports.HoverRequest || (exports.HoverRequest = {}));
|
|
/**
|
|
* How a signature help was triggered.
|
|
*
|
|
* @since 3.15.0
|
|
*/
|
|
var SignatureHelpTriggerKind;
|
|
(function (SignatureHelpTriggerKind) {
|
|
/**
|
|
* Signature help was invoked manually by the user or by a command.
|
|
*/
|
|
SignatureHelpTriggerKind.Invoked = 1;
|
|
/**
|
|
* Signature help was triggered by a trigger character.
|
|
*/
|
|
SignatureHelpTriggerKind.TriggerCharacter = 2;
|
|
/**
|
|
* Signature help was triggered by the cursor moving or by the document content changing.
|
|
*/
|
|
SignatureHelpTriggerKind.ContentChange = 3;
|
|
})(SignatureHelpTriggerKind = exports.SignatureHelpTriggerKind || (exports.SignatureHelpTriggerKind = {}));
|
|
var SignatureHelpRequest;
|
|
(function (SignatureHelpRequest) {
|
|
SignatureHelpRequest.method = 'textDocument/signatureHelp';
|
|
SignatureHelpRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
SignatureHelpRequest.type = new messages_1.ProtocolRequestType(SignatureHelpRequest.method);
|
|
})(SignatureHelpRequest = exports.SignatureHelpRequest || (exports.SignatureHelpRequest = {}));
|
|
/**
|
|
* A request to resolve the definition location of a symbol at a given text
|
|
* document position. The request's parameter is of type [TextDocumentPosition]
|
|
* (#TextDocumentPosition) the response is of either type {@link Definition}
|
|
* or a typed array of {@link DefinitionLink} or a Thenable that resolves
|
|
* to such.
|
|
*/
|
|
var DefinitionRequest;
|
|
(function (DefinitionRequest) {
|
|
DefinitionRequest.method = 'textDocument/definition';
|
|
DefinitionRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DefinitionRequest.type = new messages_1.ProtocolRequestType(DefinitionRequest.method);
|
|
})(DefinitionRequest = exports.DefinitionRequest || (exports.DefinitionRequest = {}));
|
|
/**
|
|
* A request to resolve project-wide references for the symbol denoted
|
|
* by the given text document position. The request's parameter is of
|
|
* type {@link ReferenceParams} the response is of type
|
|
* {@link Location Location[]} or a Thenable that resolves to such.
|
|
*/
|
|
var ReferencesRequest;
|
|
(function (ReferencesRequest) {
|
|
ReferencesRequest.method = 'textDocument/references';
|
|
ReferencesRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
ReferencesRequest.type = new messages_1.ProtocolRequestType(ReferencesRequest.method);
|
|
})(ReferencesRequest = exports.ReferencesRequest || (exports.ReferencesRequest = {}));
|
|
/**
|
|
* Request to resolve a {@link DocumentHighlight} for a given
|
|
* text document position. The request's parameter is of type [TextDocumentPosition]
|
|
* (#TextDocumentPosition) the request response is of type [DocumentHighlight[]]
|
|
* (#DocumentHighlight) or a Thenable that resolves to such.
|
|
*/
|
|
var DocumentHighlightRequest;
|
|
(function (DocumentHighlightRequest) {
|
|
DocumentHighlightRequest.method = 'textDocument/documentHighlight';
|
|
DocumentHighlightRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DocumentHighlightRequest.type = new messages_1.ProtocolRequestType(DocumentHighlightRequest.method);
|
|
})(DocumentHighlightRequest = exports.DocumentHighlightRequest || (exports.DocumentHighlightRequest = {}));
|
|
/**
|
|
* A request to list all symbols found in a given text document. The request's
|
|
* parameter is of type {@link TextDocumentIdentifier} the
|
|
* response is of type {@link SymbolInformation SymbolInformation[]} or a Thenable
|
|
* that resolves to such.
|
|
*/
|
|
var DocumentSymbolRequest;
|
|
(function (DocumentSymbolRequest) {
|
|
DocumentSymbolRequest.method = 'textDocument/documentSymbol';
|
|
DocumentSymbolRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DocumentSymbolRequest.type = new messages_1.ProtocolRequestType(DocumentSymbolRequest.method);
|
|
})(DocumentSymbolRequest = exports.DocumentSymbolRequest || (exports.DocumentSymbolRequest = {}));
|
|
/**
|
|
* A request to provide commands for the given text document and range.
|
|
*/
|
|
var CodeActionRequest;
|
|
(function (CodeActionRequest) {
|
|
CodeActionRequest.method = 'textDocument/codeAction';
|
|
CodeActionRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
CodeActionRequest.type = new messages_1.ProtocolRequestType(CodeActionRequest.method);
|
|
})(CodeActionRequest = exports.CodeActionRequest || (exports.CodeActionRequest = {}));
|
|
/**
|
|
* Request to resolve additional information for a given code action.The request's
|
|
* parameter is of type {@link CodeAction} the response
|
|
* is of type {@link CodeAction} or a Thenable that resolves to such.
|
|
*/
|
|
var CodeActionResolveRequest;
|
|
(function (CodeActionResolveRequest) {
|
|
CodeActionResolveRequest.method = 'codeAction/resolve';
|
|
CodeActionResolveRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
CodeActionResolveRequest.type = new messages_1.ProtocolRequestType(CodeActionResolveRequest.method);
|
|
})(CodeActionResolveRequest = exports.CodeActionResolveRequest || (exports.CodeActionResolveRequest = {}));
|
|
/**
|
|
* A request to list project-wide symbols matching the query string given
|
|
* by the {@link WorkspaceSymbolParams}. The response is
|
|
* of type {@link SymbolInformation SymbolInformation[]} or a Thenable that
|
|
* resolves to such.
|
|
*
|
|
* @since 3.17.0 - support for WorkspaceSymbol in the returned data. Clients
|
|
* need to advertise support for WorkspaceSymbols via the client capability
|
|
* `workspace.symbol.resolveSupport`.
|
|
*
|
|
*/
|
|
var WorkspaceSymbolRequest;
|
|
(function (WorkspaceSymbolRequest) {
|
|
WorkspaceSymbolRequest.method = 'workspace/symbol';
|
|
WorkspaceSymbolRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
WorkspaceSymbolRequest.type = new messages_1.ProtocolRequestType(WorkspaceSymbolRequest.method);
|
|
})(WorkspaceSymbolRequest = exports.WorkspaceSymbolRequest || (exports.WorkspaceSymbolRequest = {}));
|
|
/**
|
|
* A request to resolve the range inside the workspace
|
|
* symbol's location.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var WorkspaceSymbolResolveRequest;
|
|
(function (WorkspaceSymbolResolveRequest) {
|
|
WorkspaceSymbolResolveRequest.method = 'workspaceSymbol/resolve';
|
|
WorkspaceSymbolResolveRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
WorkspaceSymbolResolveRequest.type = new messages_1.ProtocolRequestType(WorkspaceSymbolResolveRequest.method);
|
|
})(WorkspaceSymbolResolveRequest = exports.WorkspaceSymbolResolveRequest || (exports.WorkspaceSymbolResolveRequest = {}));
|
|
/**
|
|
* A request to provide code lens for the given text document.
|
|
*/
|
|
var CodeLensRequest;
|
|
(function (CodeLensRequest) {
|
|
CodeLensRequest.method = 'textDocument/codeLens';
|
|
CodeLensRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
CodeLensRequest.type = new messages_1.ProtocolRequestType(CodeLensRequest.method);
|
|
})(CodeLensRequest = exports.CodeLensRequest || (exports.CodeLensRequest = {}));
|
|
/**
|
|
* A request to resolve a command for a given code lens.
|
|
*/
|
|
var CodeLensResolveRequest;
|
|
(function (CodeLensResolveRequest) {
|
|
CodeLensResolveRequest.method = 'codeLens/resolve';
|
|
CodeLensResolveRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
CodeLensResolveRequest.type = new messages_1.ProtocolRequestType(CodeLensResolveRequest.method);
|
|
})(CodeLensResolveRequest = exports.CodeLensResolveRequest || (exports.CodeLensResolveRequest = {}));
|
|
/**
|
|
* A request to refresh all code actions
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var CodeLensRefreshRequest;
|
|
(function (CodeLensRefreshRequest) {
|
|
CodeLensRefreshRequest.method = `workspace/codeLens/refresh`;
|
|
CodeLensRefreshRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
CodeLensRefreshRequest.type = new messages_1.ProtocolRequestType0(CodeLensRefreshRequest.method);
|
|
})(CodeLensRefreshRequest = exports.CodeLensRefreshRequest || (exports.CodeLensRefreshRequest = {}));
|
|
/**
|
|
* A request to provide document links
|
|
*/
|
|
var DocumentLinkRequest;
|
|
(function (DocumentLinkRequest) {
|
|
DocumentLinkRequest.method = 'textDocument/documentLink';
|
|
DocumentLinkRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DocumentLinkRequest.type = new messages_1.ProtocolRequestType(DocumentLinkRequest.method);
|
|
})(DocumentLinkRequest = exports.DocumentLinkRequest || (exports.DocumentLinkRequest = {}));
|
|
/**
|
|
* Request to resolve additional information for a given document link. The request's
|
|
* parameter is of type {@link DocumentLink} the response
|
|
* is of type {@link DocumentLink} or a Thenable that resolves to such.
|
|
*/
|
|
var DocumentLinkResolveRequest;
|
|
(function (DocumentLinkResolveRequest) {
|
|
DocumentLinkResolveRequest.method = 'documentLink/resolve';
|
|
DocumentLinkResolveRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DocumentLinkResolveRequest.type = new messages_1.ProtocolRequestType(DocumentLinkResolveRequest.method);
|
|
})(DocumentLinkResolveRequest = exports.DocumentLinkResolveRequest || (exports.DocumentLinkResolveRequest = {}));
|
|
/**
|
|
* A request to to format a whole document.
|
|
*/
|
|
var DocumentFormattingRequest;
|
|
(function (DocumentFormattingRequest) {
|
|
DocumentFormattingRequest.method = 'textDocument/formatting';
|
|
DocumentFormattingRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DocumentFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentFormattingRequest.method);
|
|
})(DocumentFormattingRequest = exports.DocumentFormattingRequest || (exports.DocumentFormattingRequest = {}));
|
|
/**
|
|
* A request to to format a range in a document.
|
|
*/
|
|
var DocumentRangeFormattingRequest;
|
|
(function (DocumentRangeFormattingRequest) {
|
|
DocumentRangeFormattingRequest.method = 'textDocument/rangeFormatting';
|
|
DocumentRangeFormattingRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DocumentRangeFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentRangeFormattingRequest.method);
|
|
})(DocumentRangeFormattingRequest = exports.DocumentRangeFormattingRequest || (exports.DocumentRangeFormattingRequest = {}));
|
|
/**
|
|
* A request to format a document on type.
|
|
*/
|
|
var DocumentOnTypeFormattingRequest;
|
|
(function (DocumentOnTypeFormattingRequest) {
|
|
DocumentOnTypeFormattingRequest.method = 'textDocument/onTypeFormatting';
|
|
DocumentOnTypeFormattingRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DocumentOnTypeFormattingRequest.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest.method);
|
|
})(DocumentOnTypeFormattingRequest = exports.DocumentOnTypeFormattingRequest || (exports.DocumentOnTypeFormattingRequest = {}));
|
|
//---- Rename ----------------------------------------------
|
|
var PrepareSupportDefaultBehavior;
|
|
(function (PrepareSupportDefaultBehavior) {
|
|
/**
|
|
* The client's default behavior is to select the identifier
|
|
* according the to language's syntax rule.
|
|
*/
|
|
PrepareSupportDefaultBehavior.Identifier = 1;
|
|
})(PrepareSupportDefaultBehavior = exports.PrepareSupportDefaultBehavior || (exports.PrepareSupportDefaultBehavior = {}));
|
|
/**
|
|
* A request to rename a symbol.
|
|
*/
|
|
var RenameRequest;
|
|
(function (RenameRequest) {
|
|
RenameRequest.method = 'textDocument/rename';
|
|
RenameRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
RenameRequest.type = new messages_1.ProtocolRequestType(RenameRequest.method);
|
|
})(RenameRequest = exports.RenameRequest || (exports.RenameRequest = {}));
|
|
/**
|
|
* A request to test and perform the setup necessary for a rename.
|
|
*
|
|
* @since 3.16 - support for default behavior
|
|
*/
|
|
var PrepareRenameRequest;
|
|
(function (PrepareRenameRequest) {
|
|
PrepareRenameRequest.method = 'textDocument/prepareRename';
|
|
PrepareRenameRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
PrepareRenameRequest.type = new messages_1.ProtocolRequestType(PrepareRenameRequest.method);
|
|
})(PrepareRenameRequest = exports.PrepareRenameRequest || (exports.PrepareRenameRequest = {}));
|
|
/**
|
|
* A request send from the client to the server to execute a command. The request might return
|
|
* a workspace edit which the client will apply to the workspace.
|
|
*/
|
|
var ExecuteCommandRequest;
|
|
(function (ExecuteCommandRequest) {
|
|
ExecuteCommandRequest.method = 'workspace/executeCommand';
|
|
ExecuteCommandRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
ExecuteCommandRequest.type = new messages_1.ProtocolRequestType(ExecuteCommandRequest.method);
|
|
})(ExecuteCommandRequest = exports.ExecuteCommandRequest || (exports.ExecuteCommandRequest = {}));
|
|
/**
|
|
* A request sent from the server to the client to modified certain resources.
|
|
*/
|
|
var ApplyWorkspaceEditRequest;
|
|
(function (ApplyWorkspaceEditRequest) {
|
|
ApplyWorkspaceEditRequest.method = 'workspace/applyEdit';
|
|
ApplyWorkspaceEditRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
ApplyWorkspaceEditRequest.type = new messages_1.ProtocolRequestType('workspace/applyEdit');
|
|
})(ApplyWorkspaceEditRequest = exports.ApplyWorkspaceEditRequest || (exports.ApplyWorkspaceEditRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2249:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.LinkedEditingRangeRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A request to provide ranges that can be edited together.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var LinkedEditingRangeRequest;
|
|
(function (LinkedEditingRangeRequest) {
|
|
LinkedEditingRangeRequest.method = 'textDocument/linkedEditingRange';
|
|
LinkedEditingRangeRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
LinkedEditingRangeRequest.type = new messages_1.ProtocolRequestType(LinkedEditingRangeRequest.method);
|
|
})(LinkedEditingRangeRequest = exports.LinkedEditingRangeRequest || (exports.LinkedEditingRangeRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7684:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* Moniker uniqueness level to define scope of the moniker.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var UniquenessLevel;
|
|
(function (UniquenessLevel) {
|
|
/**
|
|
* The moniker is only unique inside a document
|
|
*/
|
|
UniquenessLevel.document = 'document';
|
|
/**
|
|
* The moniker is unique inside a project for which a dump got created
|
|
*/
|
|
UniquenessLevel.project = 'project';
|
|
/**
|
|
* The moniker is unique inside the group to which a project belongs
|
|
*/
|
|
UniquenessLevel.group = 'group';
|
|
/**
|
|
* The moniker is unique inside the moniker scheme.
|
|
*/
|
|
UniquenessLevel.scheme = 'scheme';
|
|
/**
|
|
* The moniker is globally unique
|
|
*/
|
|
UniquenessLevel.global = 'global';
|
|
})(UniquenessLevel = exports.UniquenessLevel || (exports.UniquenessLevel = {}));
|
|
/**
|
|
* The moniker kind.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var MonikerKind;
|
|
(function (MonikerKind) {
|
|
/**
|
|
* The moniker represent a symbol that is imported into a project
|
|
*/
|
|
MonikerKind.$import = 'import';
|
|
/**
|
|
* The moniker represents a symbol that is exported from a project
|
|
*/
|
|
MonikerKind.$export = 'export';
|
|
/**
|
|
* The moniker represents a symbol that is local to a project (e.g. a local
|
|
* variable of a function, a class not visible outside the project, ...)
|
|
*/
|
|
MonikerKind.local = 'local';
|
|
})(MonikerKind = exports.MonikerKind || (exports.MonikerKind = {}));
|
|
/**
|
|
* A request to get the moniker of a symbol at a given text document position.
|
|
* The request parameter is of type {@link TextDocumentPositionParams}.
|
|
* The response is of type {@link Moniker Moniker[]} or `null`.
|
|
*/
|
|
var MonikerRequest;
|
|
(function (MonikerRequest) {
|
|
MonikerRequest.method = 'textDocument/moniker';
|
|
MonikerRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
MonikerRequest.type = new messages_1.ProtocolRequestType(MonikerRequest.method);
|
|
})(MonikerRequest = exports.MonikerRequest || (exports.MonikerRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4792:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.DidCloseNotebookDocumentNotification = exports.DidSaveNotebookDocumentNotification = exports.DidChangeNotebookDocumentNotification = exports.NotebookCellArrayChange = exports.DidOpenNotebookDocumentNotification = exports.NotebookDocumentSyncRegistrationType = exports.NotebookDocument = exports.NotebookCell = exports.ExecutionSummary = exports.NotebookCellKind = void 0;
|
|
const vscode_languageserver_types_1 = __webpack_require__(7717);
|
|
const Is = __webpack_require__(8633);
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A notebook cell kind.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var NotebookCellKind;
|
|
(function (NotebookCellKind) {
|
|
/**
|
|
* A markup-cell is formatted source that is used for display.
|
|
*/
|
|
NotebookCellKind.Markup = 1;
|
|
/**
|
|
* A code-cell is source code.
|
|
*/
|
|
NotebookCellKind.Code = 2;
|
|
function is(value) {
|
|
return value === 1 || value === 2;
|
|
}
|
|
NotebookCellKind.is = is;
|
|
})(NotebookCellKind = exports.NotebookCellKind || (exports.NotebookCellKind = {}));
|
|
var ExecutionSummary;
|
|
(function (ExecutionSummary) {
|
|
function create(executionOrder, success) {
|
|
const result = { executionOrder };
|
|
if (success === true || success === false) {
|
|
result.success = success;
|
|
}
|
|
return result;
|
|
}
|
|
ExecutionSummary.create = create;
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.objectLiteral(candidate) && vscode_languageserver_types_1.uinteger.is(candidate.executionOrder) && (candidate.success === undefined || Is.boolean(candidate.success));
|
|
}
|
|
ExecutionSummary.is = is;
|
|
function equals(one, other) {
|
|
if (one === other) {
|
|
return true;
|
|
}
|
|
if (one === null || one === undefined || other === null || other === undefined) {
|
|
return false;
|
|
}
|
|
return one.executionOrder === other.executionOrder && one.success === other.success;
|
|
}
|
|
ExecutionSummary.equals = equals;
|
|
})(ExecutionSummary = exports.ExecutionSummary || (exports.ExecutionSummary = {}));
|
|
var NotebookCell;
|
|
(function (NotebookCell) {
|
|
function create(kind, document) {
|
|
return { kind, document };
|
|
}
|
|
NotebookCell.create = create;
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.objectLiteral(candidate) && NotebookCellKind.is(candidate.kind) && vscode_languageserver_types_1.DocumentUri.is(candidate.document) &&
|
|
(candidate.metadata === undefined || Is.objectLiteral(candidate.metadata));
|
|
}
|
|
NotebookCell.is = is;
|
|
function diff(one, two) {
|
|
const result = new Set();
|
|
if (one.document !== two.document) {
|
|
result.add('document');
|
|
}
|
|
if (one.kind !== two.kind) {
|
|
result.add('kind');
|
|
}
|
|
if (one.executionSummary !== two.executionSummary) {
|
|
result.add('executionSummary');
|
|
}
|
|
if ((one.metadata !== undefined || two.metadata !== undefined) && !equalsMetadata(one.metadata, two.metadata)) {
|
|
result.add('metadata');
|
|
}
|
|
if ((one.executionSummary !== undefined || two.executionSummary !== undefined) && !ExecutionSummary.equals(one.executionSummary, two.executionSummary)) {
|
|
result.add('executionSummary');
|
|
}
|
|
return result;
|
|
}
|
|
NotebookCell.diff = diff;
|
|
function equalsMetadata(one, other) {
|
|
if (one === other) {
|
|
return true;
|
|
}
|
|
if (one === null || one === undefined || other === null || other === undefined) {
|
|
return false;
|
|
}
|
|
if (typeof one !== typeof other) {
|
|
return false;
|
|
}
|
|
if (typeof one !== 'object') {
|
|
return false;
|
|
}
|
|
const oneArray = Array.isArray(one);
|
|
const otherArray = Array.isArray(other);
|
|
if (oneArray !== otherArray) {
|
|
return false;
|
|
}
|
|
if (oneArray && otherArray) {
|
|
if (one.length !== other.length) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < one.length; i++) {
|
|
if (!equalsMetadata(one[i], other[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if (Is.objectLiteral(one) && Is.objectLiteral(other)) {
|
|
const oneKeys = Object.keys(one);
|
|
const otherKeys = Object.keys(other);
|
|
if (oneKeys.length !== otherKeys.length) {
|
|
return false;
|
|
}
|
|
oneKeys.sort();
|
|
otherKeys.sort();
|
|
if (!equalsMetadata(oneKeys, otherKeys)) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < oneKeys.length; i++) {
|
|
const prop = oneKeys[i];
|
|
if (!equalsMetadata(one[prop], other[prop])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
})(NotebookCell = exports.NotebookCell || (exports.NotebookCell = {}));
|
|
var NotebookDocument;
|
|
(function (NotebookDocument) {
|
|
function create(uri, notebookType, version, cells) {
|
|
return { uri, notebookType, version, cells };
|
|
}
|
|
NotebookDocument.create = create;
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.objectLiteral(candidate) && Is.string(candidate.uri) && vscode_languageserver_types_1.integer.is(candidate.version) && Is.typedArray(candidate.cells, NotebookCell.is);
|
|
}
|
|
NotebookDocument.is = is;
|
|
})(NotebookDocument = exports.NotebookDocument || (exports.NotebookDocument = {}));
|
|
var NotebookDocumentSyncRegistrationType;
|
|
(function (NotebookDocumentSyncRegistrationType) {
|
|
NotebookDocumentSyncRegistrationType.method = 'notebookDocument/sync';
|
|
NotebookDocumentSyncRegistrationType.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
NotebookDocumentSyncRegistrationType.type = new messages_1.RegistrationType(NotebookDocumentSyncRegistrationType.method);
|
|
})(NotebookDocumentSyncRegistrationType = exports.NotebookDocumentSyncRegistrationType || (exports.NotebookDocumentSyncRegistrationType = {}));
|
|
/**
|
|
* A notification sent when a notebook opens.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var DidOpenNotebookDocumentNotification;
|
|
(function (DidOpenNotebookDocumentNotification) {
|
|
DidOpenNotebookDocumentNotification.method = 'notebookDocument/didOpen';
|
|
DidOpenNotebookDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidOpenNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidOpenNotebookDocumentNotification.method);
|
|
DidOpenNotebookDocumentNotification.registrationMethod = NotebookDocumentSyncRegistrationType.method;
|
|
})(DidOpenNotebookDocumentNotification = exports.DidOpenNotebookDocumentNotification || (exports.DidOpenNotebookDocumentNotification = {}));
|
|
var NotebookCellArrayChange;
|
|
(function (NotebookCellArrayChange) {
|
|
function is(value) {
|
|
const candidate = value;
|
|
return Is.objectLiteral(candidate) && vscode_languageserver_types_1.uinteger.is(candidate.start) && vscode_languageserver_types_1.uinteger.is(candidate.deleteCount) && (candidate.cells === undefined || Is.typedArray(candidate.cells, NotebookCell.is));
|
|
}
|
|
NotebookCellArrayChange.is = is;
|
|
function create(start, deleteCount, cells) {
|
|
const result = { start, deleteCount };
|
|
if (cells !== undefined) {
|
|
result.cells = cells;
|
|
}
|
|
return result;
|
|
}
|
|
NotebookCellArrayChange.create = create;
|
|
})(NotebookCellArrayChange = exports.NotebookCellArrayChange || (exports.NotebookCellArrayChange = {}));
|
|
var DidChangeNotebookDocumentNotification;
|
|
(function (DidChangeNotebookDocumentNotification) {
|
|
DidChangeNotebookDocumentNotification.method = 'notebookDocument/didChange';
|
|
DidChangeNotebookDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidChangeNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidChangeNotebookDocumentNotification.method);
|
|
DidChangeNotebookDocumentNotification.registrationMethod = NotebookDocumentSyncRegistrationType.method;
|
|
})(DidChangeNotebookDocumentNotification = exports.DidChangeNotebookDocumentNotification || (exports.DidChangeNotebookDocumentNotification = {}));
|
|
/**
|
|
* A notification sent when a notebook document is saved.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var DidSaveNotebookDocumentNotification;
|
|
(function (DidSaveNotebookDocumentNotification) {
|
|
DidSaveNotebookDocumentNotification.method = 'notebookDocument/didSave';
|
|
DidSaveNotebookDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidSaveNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidSaveNotebookDocumentNotification.method);
|
|
DidSaveNotebookDocumentNotification.registrationMethod = NotebookDocumentSyncRegistrationType.method;
|
|
})(DidSaveNotebookDocumentNotification = exports.DidSaveNotebookDocumentNotification || (exports.DidSaveNotebookDocumentNotification = {}));
|
|
/**
|
|
* A notification sent when a notebook closes.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var DidCloseNotebookDocumentNotification;
|
|
(function (DidCloseNotebookDocumentNotification) {
|
|
DidCloseNotebookDocumentNotification.method = 'notebookDocument/didClose';
|
|
DidCloseNotebookDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidCloseNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidCloseNotebookDocumentNotification.method);
|
|
DidCloseNotebookDocumentNotification.registrationMethod = NotebookDocumentSyncRegistrationType.method;
|
|
})(DidCloseNotebookDocumentNotification = exports.DidCloseNotebookDocumentNotification || (exports.DidCloseNotebookDocumentNotification = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4166:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = void 0;
|
|
const vscode_jsonrpc_1 = __webpack_require__(9110);
|
|
const messages_1 = __webpack_require__(8431);
|
|
var WorkDoneProgress;
|
|
(function (WorkDoneProgress) {
|
|
WorkDoneProgress.type = new vscode_jsonrpc_1.ProgressType();
|
|
function is(value) {
|
|
return value === WorkDoneProgress.type;
|
|
}
|
|
WorkDoneProgress.is = is;
|
|
})(WorkDoneProgress = exports.WorkDoneProgress || (exports.WorkDoneProgress = {}));
|
|
/**
|
|
* The `window/workDoneProgress/create` request is sent from the server to the client to initiate progress
|
|
* reporting from the server.
|
|
*/
|
|
var WorkDoneProgressCreateRequest;
|
|
(function (WorkDoneProgressCreateRequest) {
|
|
WorkDoneProgressCreateRequest.method = 'window/workDoneProgress/create';
|
|
WorkDoneProgressCreateRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
WorkDoneProgressCreateRequest.type = new messages_1.ProtocolRequestType(WorkDoneProgressCreateRequest.method);
|
|
})(WorkDoneProgressCreateRequest = exports.WorkDoneProgressCreateRequest || (exports.WorkDoneProgressCreateRequest = {}));
|
|
/**
|
|
* The `window/workDoneProgress/cancel` notification is sent from the client to the server to cancel a progress
|
|
* initiated on the server side.
|
|
*/
|
|
var WorkDoneProgressCancelNotification;
|
|
(function (WorkDoneProgressCancelNotification) {
|
|
WorkDoneProgressCancelNotification.method = 'window/workDoneProgress/cancel';
|
|
WorkDoneProgressCancelNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
WorkDoneProgressCancelNotification.type = new messages_1.ProtocolNotificationType(WorkDoneProgressCancelNotification.method);
|
|
})(WorkDoneProgressCancelNotification = exports.WorkDoneProgressCancelNotification || (exports.WorkDoneProgressCancelNotification = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1530:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.SelectionRangeRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A request to provide selection ranges in a document. The request's
|
|
* parameter is of type {@link SelectionRangeParams}, the
|
|
* response is of type {@link SelectionRange SelectionRange[]} or a Thenable
|
|
* that resolves to such.
|
|
*/
|
|
var SelectionRangeRequest;
|
|
(function (SelectionRangeRequest) {
|
|
SelectionRangeRequest.method = 'textDocument/selectionRange';
|
|
SelectionRangeRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
SelectionRangeRequest.type = new messages_1.ProtocolRequestType(SelectionRangeRequest.method);
|
|
})(SelectionRangeRequest = exports.SelectionRangeRequest || (exports.SelectionRangeRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2067:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.SemanticTokensRegistrationType = exports.TokenFormat = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
//------- 'textDocument/semanticTokens' -----
|
|
var TokenFormat;
|
|
(function (TokenFormat) {
|
|
TokenFormat.Relative = 'relative';
|
|
})(TokenFormat = exports.TokenFormat || (exports.TokenFormat = {}));
|
|
var SemanticTokensRegistrationType;
|
|
(function (SemanticTokensRegistrationType) {
|
|
SemanticTokensRegistrationType.method = 'textDocument/semanticTokens';
|
|
SemanticTokensRegistrationType.type = new messages_1.RegistrationType(SemanticTokensRegistrationType.method);
|
|
})(SemanticTokensRegistrationType = exports.SemanticTokensRegistrationType || (exports.SemanticTokensRegistrationType = {}));
|
|
/**
|
|
* @since 3.16.0
|
|
*/
|
|
var SemanticTokensRequest;
|
|
(function (SemanticTokensRequest) {
|
|
SemanticTokensRequest.method = 'textDocument/semanticTokens/full';
|
|
SemanticTokensRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
SemanticTokensRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRequest.method);
|
|
SemanticTokensRequest.registrationMethod = SemanticTokensRegistrationType.method;
|
|
})(SemanticTokensRequest = exports.SemanticTokensRequest || (exports.SemanticTokensRequest = {}));
|
|
/**
|
|
* @since 3.16.0
|
|
*/
|
|
var SemanticTokensDeltaRequest;
|
|
(function (SemanticTokensDeltaRequest) {
|
|
SemanticTokensDeltaRequest.method = 'textDocument/semanticTokens/full/delta';
|
|
SemanticTokensDeltaRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
SemanticTokensDeltaRequest.type = new messages_1.ProtocolRequestType(SemanticTokensDeltaRequest.method);
|
|
SemanticTokensDeltaRequest.registrationMethod = SemanticTokensRegistrationType.method;
|
|
})(SemanticTokensDeltaRequest = exports.SemanticTokensDeltaRequest || (exports.SemanticTokensDeltaRequest = {}));
|
|
/**
|
|
* @since 3.16.0
|
|
*/
|
|
var SemanticTokensRangeRequest;
|
|
(function (SemanticTokensRangeRequest) {
|
|
SemanticTokensRangeRequest.method = 'textDocument/semanticTokens/range';
|
|
SemanticTokensRangeRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
SemanticTokensRangeRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest.method);
|
|
SemanticTokensRangeRequest.registrationMethod = SemanticTokensRegistrationType.method;
|
|
})(SemanticTokensRangeRequest = exports.SemanticTokensRangeRequest || (exports.SemanticTokensRangeRequest = {}));
|
|
/**
|
|
* @since 3.16.0
|
|
*/
|
|
var SemanticTokensRefreshRequest;
|
|
(function (SemanticTokensRefreshRequest) {
|
|
SemanticTokensRefreshRequest.method = `workspace/semanticTokens/refresh`;
|
|
SemanticTokensRefreshRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
SemanticTokensRefreshRequest.type = new messages_1.ProtocolRequestType0(SemanticTokensRefreshRequest.method);
|
|
})(SemanticTokensRefreshRequest = exports.SemanticTokensRefreshRequest || (exports.SemanticTokensRefreshRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4333:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.ShowDocumentRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A request to show a document. This request might open an
|
|
* external program depending on the value of the URI to open.
|
|
* For example a request to open `https://code.visualstudio.com/`
|
|
* will very likely open the URI in a WEB browser.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var ShowDocumentRequest;
|
|
(function (ShowDocumentRequest) {
|
|
ShowDocumentRequest.method = 'window/showDocument';
|
|
ShowDocumentRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
ShowDocumentRequest.type = new messages_1.ProtocolRequestType(ShowDocumentRequest.method);
|
|
})(ShowDocumentRequest = exports.ShowDocumentRequest || (exports.ShowDocumentRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9264:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.TypeDefinitionRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
// @ts-ignore: to avoid inlining LocatioLink as dynamic import
|
|
let __noDynamicImport;
|
|
/**
|
|
* A request to resolve the type definition locations of a symbol at a given text
|
|
* document position. The request's parameter is of type [TextDocumentPositionParams]
|
|
* (#TextDocumentPositionParams) the response is of type {@link Definition} or a
|
|
* Thenable that resolves to such.
|
|
*/
|
|
var TypeDefinitionRequest;
|
|
(function (TypeDefinitionRequest) {
|
|
TypeDefinitionRequest.method = 'textDocument/typeDefinition';
|
|
TypeDefinitionRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
TypeDefinitionRequest.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest.method);
|
|
})(TypeDefinitionRequest = exports.TypeDefinitionRequest || (exports.TypeDefinitionRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7062:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) TypeFox, Microsoft and others. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.TypeHierarchySubtypesRequest = exports.TypeHierarchySupertypesRequest = exports.TypeHierarchyPrepareRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* A request to result a `TypeHierarchyItem` in a document at a given position.
|
|
* Can be used as an input to a subtypes or supertypes type hierarchy.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var TypeHierarchyPrepareRequest;
|
|
(function (TypeHierarchyPrepareRequest) {
|
|
TypeHierarchyPrepareRequest.method = 'textDocument/prepareTypeHierarchy';
|
|
TypeHierarchyPrepareRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
TypeHierarchyPrepareRequest.type = new messages_1.ProtocolRequestType(TypeHierarchyPrepareRequest.method);
|
|
})(TypeHierarchyPrepareRequest = exports.TypeHierarchyPrepareRequest || (exports.TypeHierarchyPrepareRequest = {}));
|
|
/**
|
|
* A request to resolve the supertypes for a given `TypeHierarchyItem`.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var TypeHierarchySupertypesRequest;
|
|
(function (TypeHierarchySupertypesRequest) {
|
|
TypeHierarchySupertypesRequest.method = 'typeHierarchy/supertypes';
|
|
TypeHierarchySupertypesRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
TypeHierarchySupertypesRequest.type = new messages_1.ProtocolRequestType(TypeHierarchySupertypesRequest.method);
|
|
})(TypeHierarchySupertypesRequest = exports.TypeHierarchySupertypesRequest || (exports.TypeHierarchySupertypesRequest = {}));
|
|
/**
|
|
* A request to resolve the subtypes for a given `TypeHierarchyItem`.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var TypeHierarchySubtypesRequest;
|
|
(function (TypeHierarchySubtypesRequest) {
|
|
TypeHierarchySubtypesRequest.method = 'typeHierarchy/subtypes';
|
|
TypeHierarchySubtypesRequest.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
TypeHierarchySubtypesRequest.type = new messages_1.ProtocolRequestType(TypeHierarchySubtypesRequest.method);
|
|
})(TypeHierarchySubtypesRequest = exports.TypeHierarchySubtypesRequest || (exports.TypeHierarchySubtypesRequest = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6860:
|
|
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = void 0;
|
|
const messages_1 = __webpack_require__(8431);
|
|
/**
|
|
* The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders.
|
|
*/
|
|
var WorkspaceFoldersRequest;
|
|
(function (WorkspaceFoldersRequest) {
|
|
WorkspaceFoldersRequest.method = 'workspace/workspaceFolders';
|
|
WorkspaceFoldersRequest.messageDirection = messages_1.MessageDirection.serverToClient;
|
|
WorkspaceFoldersRequest.type = new messages_1.ProtocolRequestType0(WorkspaceFoldersRequest.method);
|
|
})(WorkspaceFoldersRequest = exports.WorkspaceFoldersRequest || (exports.WorkspaceFoldersRequest = {}));
|
|
/**
|
|
* The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace
|
|
* folder configuration changes.
|
|
*/
|
|
var DidChangeWorkspaceFoldersNotification;
|
|
(function (DidChangeWorkspaceFoldersNotification) {
|
|
DidChangeWorkspaceFoldersNotification.method = 'workspace/didChangeWorkspaceFolders';
|
|
DidChangeWorkspaceFoldersNotification.messageDirection = messages_1.MessageDirection.clientToServer;
|
|
DidChangeWorkspaceFoldersNotification.type = new messages_1.ProtocolNotificationType(DidChangeWorkspaceFoldersNotification.method);
|
|
})(DidChangeWorkspaceFoldersNotification = exports.DidChangeWorkspaceFoldersNotification || (exports.DidChangeWorkspaceFoldersNotification = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8633:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
"use strict";
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
exports.objectLiteral = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
|
|
function boolean(value) {
|
|
return value === true || value === false;
|
|
}
|
|
exports.boolean = boolean;
|
|
function string(value) {
|
|
return typeof value === 'string' || value instanceof String;
|
|
}
|
|
exports.string = string;
|
|
function number(value) {
|
|
return typeof value === 'number' || value instanceof Number;
|
|
}
|
|
exports.number = number;
|
|
function error(value) {
|
|
return value instanceof Error;
|
|
}
|
|
exports.error = error;
|
|
function func(value) {
|
|
return typeof value === 'function';
|
|
}
|
|
exports.func = func;
|
|
function array(value) {
|
|
return Array.isArray(value);
|
|
}
|
|
exports.array = array;
|
|
function stringArray(value) {
|
|
return array(value) && value.every(elem => string(elem));
|
|
}
|
|
exports.stringArray = stringArray;
|
|
function typedArray(value, check) {
|
|
return Array.isArray(value) && value.every(check);
|
|
}
|
|
exports.typedArray = typedArray;
|
|
function objectLiteral(value) {
|
|
// Strictly speaking class instances pass this check as well. Since the LSP
|
|
// doesn't use classes we ignore this for now. If we do we need to add something
|
|
// like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`
|
|
return value !== null && typeof value === 'object';
|
|
}
|
|
exports.objectLiteral = objectLiteral;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7717:
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ AnnotatedTextEdit: () => (/* binding */ AnnotatedTextEdit),
|
|
/* harmony export */ ChangeAnnotation: () => (/* binding */ ChangeAnnotation),
|
|
/* harmony export */ ChangeAnnotationIdentifier: () => (/* binding */ ChangeAnnotationIdentifier),
|
|
/* harmony export */ CodeAction: () => (/* binding */ CodeAction),
|
|
/* harmony export */ CodeActionContext: () => (/* binding */ CodeActionContext),
|
|
/* harmony export */ CodeActionKind: () => (/* binding */ CodeActionKind),
|
|
/* harmony export */ CodeActionTriggerKind: () => (/* binding */ CodeActionTriggerKind),
|
|
/* harmony export */ CodeDescription: () => (/* binding */ CodeDescription),
|
|
/* harmony export */ CodeLens: () => (/* binding */ CodeLens),
|
|
/* harmony export */ Color: () => (/* binding */ Color),
|
|
/* harmony export */ ColorInformation: () => (/* binding */ ColorInformation),
|
|
/* harmony export */ ColorPresentation: () => (/* binding */ ColorPresentation),
|
|
/* harmony export */ Command: () => (/* binding */ Command),
|
|
/* harmony export */ CompletionItem: () => (/* binding */ CompletionItem),
|
|
/* harmony export */ CompletionItemKind: () => (/* binding */ CompletionItemKind),
|
|
/* harmony export */ CompletionItemLabelDetails: () => (/* binding */ CompletionItemLabelDetails),
|
|
/* harmony export */ CompletionItemTag: () => (/* binding */ CompletionItemTag),
|
|
/* harmony export */ CompletionList: () => (/* binding */ CompletionList),
|
|
/* harmony export */ CreateFile: () => (/* binding */ CreateFile),
|
|
/* harmony export */ DeleteFile: () => (/* binding */ DeleteFile),
|
|
/* harmony export */ Diagnostic: () => (/* binding */ Diagnostic),
|
|
/* harmony export */ DiagnosticRelatedInformation: () => (/* binding */ DiagnosticRelatedInformation),
|
|
/* harmony export */ DiagnosticSeverity: () => (/* binding */ DiagnosticSeverity),
|
|
/* harmony export */ DiagnosticTag: () => (/* binding */ DiagnosticTag),
|
|
/* harmony export */ DocumentHighlight: () => (/* binding */ DocumentHighlight),
|
|
/* harmony export */ DocumentHighlightKind: () => (/* binding */ DocumentHighlightKind),
|
|
/* harmony export */ DocumentLink: () => (/* binding */ DocumentLink),
|
|
/* harmony export */ DocumentSymbol: () => (/* binding */ DocumentSymbol),
|
|
/* harmony export */ DocumentUri: () => (/* binding */ DocumentUri),
|
|
/* harmony export */ EOL: () => (/* binding */ EOL),
|
|
/* harmony export */ FoldingRange: () => (/* binding */ FoldingRange),
|
|
/* harmony export */ FoldingRangeKind: () => (/* binding */ FoldingRangeKind),
|
|
/* harmony export */ FormattingOptions: () => (/* binding */ FormattingOptions),
|
|
/* harmony export */ Hover: () => (/* binding */ Hover),
|
|
/* harmony export */ InlayHint: () => (/* binding */ InlayHint),
|
|
/* harmony export */ InlayHintKind: () => (/* binding */ InlayHintKind),
|
|
/* harmony export */ InlayHintLabelPart: () => (/* binding */ InlayHintLabelPart),
|
|
/* harmony export */ InlineValueContext: () => (/* binding */ InlineValueContext),
|
|
/* harmony export */ InlineValueEvaluatableExpression: () => (/* binding */ InlineValueEvaluatableExpression),
|
|
/* harmony export */ InlineValueText: () => (/* binding */ InlineValueText),
|
|
/* harmony export */ InlineValueVariableLookup: () => (/* binding */ InlineValueVariableLookup),
|
|
/* harmony export */ InsertReplaceEdit: () => (/* binding */ InsertReplaceEdit),
|
|
/* harmony export */ InsertTextFormat: () => (/* binding */ InsertTextFormat),
|
|
/* harmony export */ InsertTextMode: () => (/* binding */ InsertTextMode),
|
|
/* harmony export */ Location: () => (/* binding */ Location),
|
|
/* harmony export */ LocationLink: () => (/* binding */ LocationLink),
|
|
/* harmony export */ MarkedString: () => (/* binding */ MarkedString),
|
|
/* harmony export */ MarkupContent: () => (/* binding */ MarkupContent),
|
|
/* harmony export */ MarkupKind: () => (/* binding */ MarkupKind),
|
|
/* harmony export */ OptionalVersionedTextDocumentIdentifier: () => (/* binding */ OptionalVersionedTextDocumentIdentifier),
|
|
/* harmony export */ ParameterInformation: () => (/* binding */ ParameterInformation),
|
|
/* harmony export */ Position: () => (/* binding */ Position),
|
|
/* harmony export */ Range: () => (/* binding */ Range),
|
|
/* harmony export */ RenameFile: () => (/* binding */ RenameFile),
|
|
/* harmony export */ SelectionRange: () => (/* binding */ SelectionRange),
|
|
/* harmony export */ SemanticTokenModifiers: () => (/* binding */ SemanticTokenModifiers),
|
|
/* harmony export */ SemanticTokenTypes: () => (/* binding */ SemanticTokenTypes),
|
|
/* harmony export */ SemanticTokens: () => (/* binding */ SemanticTokens),
|
|
/* harmony export */ SignatureInformation: () => (/* binding */ SignatureInformation),
|
|
/* harmony export */ SymbolInformation: () => (/* binding */ SymbolInformation),
|
|
/* harmony export */ SymbolKind: () => (/* binding */ SymbolKind),
|
|
/* harmony export */ SymbolTag: () => (/* binding */ SymbolTag),
|
|
/* harmony export */ TextDocument: () => (/* binding */ TextDocument),
|
|
/* harmony export */ TextDocumentEdit: () => (/* binding */ TextDocumentEdit),
|
|
/* harmony export */ TextDocumentIdentifier: () => (/* binding */ TextDocumentIdentifier),
|
|
/* harmony export */ TextDocumentItem: () => (/* binding */ TextDocumentItem),
|
|
/* harmony export */ TextEdit: () => (/* binding */ TextEdit),
|
|
/* harmony export */ URI: () => (/* binding */ URI),
|
|
/* harmony export */ VersionedTextDocumentIdentifier: () => (/* binding */ VersionedTextDocumentIdentifier),
|
|
/* harmony export */ WorkspaceChange: () => (/* binding */ WorkspaceChange),
|
|
/* harmony export */ WorkspaceEdit: () => (/* binding */ WorkspaceEdit),
|
|
/* harmony export */ WorkspaceFolder: () => (/* binding */ WorkspaceFolder),
|
|
/* harmony export */ WorkspaceSymbol: () => (/* binding */ WorkspaceSymbol),
|
|
/* harmony export */ integer: () => (/* binding */ integer),
|
|
/* harmony export */ uinteger: () => (/* binding */ uinteger)
|
|
/* harmony export */ });
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
|
|
var DocumentUri;
|
|
(function (DocumentUri) {
|
|
function is(value) {
|
|
return typeof value === 'string';
|
|
}
|
|
DocumentUri.is = is;
|
|
})(DocumentUri || (DocumentUri = {}));
|
|
var URI;
|
|
(function (URI) {
|
|
function is(value) {
|
|
return typeof value === 'string';
|
|
}
|
|
URI.is = is;
|
|
})(URI || (URI = {}));
|
|
var integer;
|
|
(function (integer) {
|
|
integer.MIN_VALUE = -2147483648;
|
|
integer.MAX_VALUE = 2147483647;
|
|
function is(value) {
|
|
return typeof value === 'number' && integer.MIN_VALUE <= value && value <= integer.MAX_VALUE;
|
|
}
|
|
integer.is = is;
|
|
})(integer || (integer = {}));
|
|
var uinteger;
|
|
(function (uinteger) {
|
|
uinteger.MIN_VALUE = 0;
|
|
uinteger.MAX_VALUE = 2147483647;
|
|
function is(value) {
|
|
return typeof value === 'number' && uinteger.MIN_VALUE <= value && value <= uinteger.MAX_VALUE;
|
|
}
|
|
uinteger.is = is;
|
|
})(uinteger || (uinteger = {}));
|
|
/**
|
|
* The Position namespace provides helper functions to work with
|
|
* {@link Position} literals.
|
|
*/
|
|
var Position;
|
|
(function (Position) {
|
|
/**
|
|
* Creates a new Position literal from the given line and character.
|
|
* @param line The position's line.
|
|
* @param character The position's character.
|
|
*/
|
|
function create(line, character) {
|
|
if (line === Number.MAX_VALUE) {
|
|
line = uinteger.MAX_VALUE;
|
|
}
|
|
if (character === Number.MAX_VALUE) {
|
|
character = uinteger.MAX_VALUE;
|
|
}
|
|
return { line: line, character: character };
|
|
}
|
|
Position.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link Position} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
|
|
}
|
|
Position.is = is;
|
|
})(Position || (Position = {}));
|
|
/**
|
|
* The Range namespace provides helper functions to work with
|
|
* {@link Range} literals.
|
|
*/
|
|
var Range;
|
|
(function (Range) {
|
|
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[".concat(one, ", ").concat(two, ", ").concat(three, ", ").concat(four, "]"));
|
|
}
|
|
}
|
|
Range.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link Range} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
|
|
}
|
|
Range.is = is;
|
|
})(Range || (Range = {}));
|
|
/**
|
|
* The Location namespace provides helper functions to work with
|
|
* {@link Location} literals.
|
|
*/
|
|
var Location;
|
|
(function (Location) {
|
|
/**
|
|
* Creates a Location literal.
|
|
* @param uri The location's uri.
|
|
* @param range The location's range.
|
|
*/
|
|
function create(uri, range) {
|
|
return { uri: uri, range: range };
|
|
}
|
|
Location.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link Location} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
|
|
}
|
|
Location.is = is;
|
|
})(Location || (Location = {}));
|
|
/**
|
|
* The LocationLink namespace provides helper functions to work with
|
|
* {@link LocationLink} literals.
|
|
*/
|
|
var LocationLink;
|
|
(function (LocationLink) {
|
|
/**
|
|
* Creates a LocationLink literal.
|
|
* @param targetUri The definition's uri.
|
|
* @param targetRange The full range of the definition.
|
|
* @param targetSelectionRange The span of the symbol definition at the target.
|
|
* @param originSelectionRange The span of the symbol being defined in the originating source file.
|
|
*/
|
|
function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
|
|
return { targetUri: targetUri, targetRange: targetRange, targetSelectionRange: targetSelectionRange, originSelectionRange: originSelectionRange };
|
|
}
|
|
LocationLink.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link LocationLink} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri)
|
|
&& Range.is(candidate.targetSelectionRange)
|
|
&& (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
|
|
}
|
|
LocationLink.is = is;
|
|
})(LocationLink || (LocationLink = {}));
|
|
/**
|
|
* The Color namespace provides helper functions to work with
|
|
* {@link Color} literals.
|
|
*/
|
|
var Color;
|
|
(function (Color) {
|
|
/**
|
|
* Creates a new Color literal.
|
|
*/
|
|
function create(red, green, blue, alpha) {
|
|
return {
|
|
red: red,
|
|
green: green,
|
|
blue: blue,
|
|
alpha: alpha,
|
|
};
|
|
}
|
|
Color.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link Color} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1)
|
|
&& Is.numberRange(candidate.green, 0, 1)
|
|
&& Is.numberRange(candidate.blue, 0, 1)
|
|
&& Is.numberRange(candidate.alpha, 0, 1);
|
|
}
|
|
Color.is = is;
|
|
})(Color || (Color = {}));
|
|
/**
|
|
* The ColorInformation namespace provides helper functions to work with
|
|
* {@link ColorInformation} literals.
|
|
*/
|
|
var ColorInformation;
|
|
(function (ColorInformation) {
|
|
/**
|
|
* Creates a new ColorInformation literal.
|
|
*/
|
|
function create(range, color) {
|
|
return {
|
|
range: range,
|
|
color: color,
|
|
};
|
|
}
|
|
ColorInformation.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link ColorInformation} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Range.is(candidate.range) && Color.is(candidate.color);
|
|
}
|
|
ColorInformation.is = is;
|
|
})(ColorInformation || (ColorInformation = {}));
|
|
/**
|
|
* The Color namespace provides helper functions to work with
|
|
* {@link ColorPresentation} literals.
|
|
*/
|
|
var ColorPresentation;
|
|
(function (ColorPresentation) {
|
|
/**
|
|
* Creates a new ColorInformation literal.
|
|
*/
|
|
function create(label, textEdit, additionalTextEdits) {
|
|
return {
|
|
label: label,
|
|
textEdit: textEdit,
|
|
additionalTextEdits: additionalTextEdits,
|
|
};
|
|
}
|
|
ColorPresentation.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link ColorInformation} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Is.string(candidate.label)
|
|
&& (Is.undefined(candidate.textEdit) || TextEdit.is(candidate))
|
|
&& (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
|
|
}
|
|
ColorPresentation.is = is;
|
|
})(ColorPresentation || (ColorPresentation = {}));
|
|
/**
|
|
* A set of predefined range kinds.
|
|
*/
|
|
var FoldingRangeKind;
|
|
(function (FoldingRangeKind) {
|
|
/**
|
|
* Folding range for a comment
|
|
*/
|
|
FoldingRangeKind.Comment = 'comment';
|
|
/**
|
|
* Folding range for an import or include
|
|
*/
|
|
FoldingRangeKind.Imports = 'imports';
|
|
/**
|
|
* Folding range for a region (e.g. `#region`)
|
|
*/
|
|
FoldingRangeKind.Region = 'region';
|
|
})(FoldingRangeKind || (FoldingRangeKind = {}));
|
|
/**
|
|
* The folding range namespace provides helper functions to work with
|
|
* {@link FoldingRange} literals.
|
|
*/
|
|
var FoldingRange;
|
|
(function (FoldingRange) {
|
|
/**
|
|
* Creates a new FoldingRange literal.
|
|
*/
|
|
function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {
|
|
var result = {
|
|
startLine: startLine,
|
|
endLine: endLine
|
|
};
|
|
if (Is.defined(startCharacter)) {
|
|
result.startCharacter = startCharacter;
|
|
}
|
|
if (Is.defined(endCharacter)) {
|
|
result.endCharacter = endCharacter;
|
|
}
|
|
if (Is.defined(kind)) {
|
|
result.kind = kind;
|
|
}
|
|
if (Is.defined(collapsedText)) {
|
|
result.collapsedText = collapsedText;
|
|
}
|
|
return result;
|
|
}
|
|
FoldingRange.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link FoldingRange} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && 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));
|
|
}
|
|
FoldingRange.is = is;
|
|
})(FoldingRange || (FoldingRange = {}));
|
|
/**
|
|
* The DiagnosticRelatedInformation namespace provides helper functions to work with
|
|
* {@link DiagnosticRelatedInformation} literals.
|
|
*/
|
|
var DiagnosticRelatedInformation;
|
|
(function (DiagnosticRelatedInformation) {
|
|
/**
|
|
* Creates a new DiagnosticRelatedInformation literal.
|
|
*/
|
|
function create(location, message) {
|
|
return {
|
|
location: location,
|
|
message: message
|
|
};
|
|
}
|
|
DiagnosticRelatedInformation.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link DiagnosticRelatedInformation} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
|
|
}
|
|
DiagnosticRelatedInformation.is = is;
|
|
})(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
|
|
/**
|
|
* The diagnostic's severity.
|
|
*/
|
|
var DiagnosticSeverity;
|
|
(function (DiagnosticSeverity) {
|
|
/**
|
|
* Reports an error.
|
|
*/
|
|
DiagnosticSeverity.Error = 1;
|
|
/**
|
|
* Reports a warning.
|
|
*/
|
|
DiagnosticSeverity.Warning = 2;
|
|
/**
|
|
* Reports an information.
|
|
*/
|
|
DiagnosticSeverity.Information = 3;
|
|
/**
|
|
* Reports a hint.
|
|
*/
|
|
DiagnosticSeverity.Hint = 4;
|
|
})(DiagnosticSeverity || (DiagnosticSeverity = {}));
|
|
/**
|
|
* The diagnostic tags.
|
|
*
|
|
* @since 3.15.0
|
|
*/
|
|
var DiagnosticTag;
|
|
(function (DiagnosticTag) {
|
|
/**
|
|
* Unused or unnecessary code.
|
|
*
|
|
* Clients are allowed to render diagnostics with this tag faded out instead of having
|
|
* an error squiggle.
|
|
*/
|
|
DiagnosticTag.Unnecessary = 1;
|
|
/**
|
|
* Deprecated or obsolete code.
|
|
*
|
|
* Clients are allowed to rendered diagnostics with this tag strike through.
|
|
*/
|
|
DiagnosticTag.Deprecated = 2;
|
|
})(DiagnosticTag || (DiagnosticTag = {}));
|
|
/**
|
|
* The CodeDescription namespace provides functions to deal with descriptions for diagnostic codes.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var CodeDescription;
|
|
(function (CodeDescription) {
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Is.string(candidate.href);
|
|
}
|
|
CodeDescription.is = is;
|
|
})(CodeDescription || (CodeDescription = {}));
|
|
/**
|
|
* The Diagnostic namespace provides helper functions to work with
|
|
* {@link Diagnostic} literals.
|
|
*/
|
|
var Diagnostic;
|
|
(function (Diagnostic) {
|
|
/**
|
|
* Creates a new Diagnostic literal.
|
|
*/
|
|
function create(range, message, severity, code, source, relatedInformation) {
|
|
var result = { range: range, message: 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;
|
|
}
|
|
Diagnostic.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link Diagnostic} interface.
|
|
*/
|
|
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));
|
|
}
|
|
Diagnostic.is = is;
|
|
})(Diagnostic || (Diagnostic = {}));
|
|
/**
|
|
* The Command namespace provides helper functions to work with
|
|
* {@link Command} literals.
|
|
*/
|
|
var Command;
|
|
(function (Command) {
|
|
/**
|
|
* Creates a new Command literal.
|
|
*/
|
|
function create(title, command) {
|
|
var args = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
args[_i - 2] = arguments[_i];
|
|
}
|
|
var result = { title: title, command: command };
|
|
if (Is.defined(args) && args.length > 0) {
|
|
result.arguments = args;
|
|
}
|
|
return result;
|
|
}
|
|
Command.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link Command} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
|
|
}
|
|
Command.is = is;
|
|
})(Command || (Command = {}));
|
|
/**
|
|
* The TextEdit namespace provides helper function to create replace,
|
|
* insert and delete edits more easily.
|
|
*/
|
|
var TextEdit;
|
|
(function (TextEdit) {
|
|
/**
|
|
* Creates a replace text edit.
|
|
* @param range The range of text to be replaced.
|
|
* @param newText The new text.
|
|
*/
|
|
function replace(range, newText) {
|
|
return { range: range, newText: newText };
|
|
}
|
|
TextEdit.replace = replace;
|
|
/**
|
|
* Creates an insert text edit.
|
|
* @param position The position to insert the text at.
|
|
* @param newText The text to be inserted.
|
|
*/
|
|
function insert(position, newText) {
|
|
return { range: { start: position, end: position }, newText: newText };
|
|
}
|
|
TextEdit.insert = insert;
|
|
/**
|
|
* Creates a delete text edit.
|
|
* @param range The range of text to be deleted.
|
|
*/
|
|
function del(range) {
|
|
return { range: range, newText: '' };
|
|
}
|
|
TextEdit.del = del;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate)
|
|
&& Is.string(candidate.newText)
|
|
&& Range.is(candidate.range);
|
|
}
|
|
TextEdit.is = is;
|
|
})(TextEdit || (TextEdit = {}));
|
|
var ChangeAnnotation;
|
|
(function (ChangeAnnotation) {
|
|
function create(label, needsConfirmation, description) {
|
|
var result = { label: label };
|
|
if (needsConfirmation !== undefined) {
|
|
result.needsConfirmation = needsConfirmation;
|
|
}
|
|
if (description !== undefined) {
|
|
result.description = description;
|
|
}
|
|
return result;
|
|
}
|
|
ChangeAnnotation.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Is.string(candidate.label) &&
|
|
(Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === undefined) &&
|
|
(Is.string(candidate.description) || candidate.description === undefined);
|
|
}
|
|
ChangeAnnotation.is = is;
|
|
})(ChangeAnnotation || (ChangeAnnotation = {}));
|
|
var ChangeAnnotationIdentifier;
|
|
(function (ChangeAnnotationIdentifier) {
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.string(candidate);
|
|
}
|
|
ChangeAnnotationIdentifier.is = is;
|
|
})(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
|
|
var AnnotatedTextEdit;
|
|
(function (AnnotatedTextEdit) {
|
|
/**
|
|
* Creates an annotated replace text edit.
|
|
*
|
|
* @param range The range of text to be replaced.
|
|
* @param newText The new text.
|
|
* @param annotation The annotation.
|
|
*/
|
|
function replace(range, newText, annotation) {
|
|
return { range: range, newText: newText, annotationId: annotation };
|
|
}
|
|
AnnotatedTextEdit.replace = replace;
|
|
/**
|
|
* Creates an annotated insert text edit.
|
|
*
|
|
* @param position The position to insert the text at.
|
|
* @param newText The text to be inserted.
|
|
* @param annotation The annotation.
|
|
*/
|
|
function insert(position, newText, annotation) {
|
|
return { range: { start: position, end: position }, newText: newText, annotationId: annotation };
|
|
}
|
|
AnnotatedTextEdit.insert = insert;
|
|
/**
|
|
* Creates an annotated delete text edit.
|
|
*
|
|
* @param range The range of text to be deleted.
|
|
* @param annotation The annotation.
|
|
*/
|
|
function del(range, annotation) {
|
|
return { range: range, newText: '', annotationId: annotation };
|
|
}
|
|
AnnotatedTextEdit.del = del;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
|
|
}
|
|
AnnotatedTextEdit.is = is;
|
|
})(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
|
|
/**
|
|
* The TextDocumentEdit namespace provides helper function to create
|
|
* an edit that manipulates a text document.
|
|
*/
|
|
var TextDocumentEdit;
|
|
(function (TextDocumentEdit) {
|
|
/**
|
|
* Creates a new `TextDocumentEdit`
|
|
*/
|
|
function create(textDocument, edits) {
|
|
return { textDocument: textDocument, edits: edits };
|
|
}
|
|
TextDocumentEdit.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate)
|
|
&& OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument)
|
|
&& Array.isArray(candidate.edits);
|
|
}
|
|
TextDocumentEdit.is = is;
|
|
})(TextDocumentEdit || (TextDocumentEdit = {}));
|
|
var CreateFile;
|
|
(function (CreateFile) {
|
|
function create(uri, options, annotation) {
|
|
var result = {
|
|
kind: 'create',
|
|
uri: uri
|
|
};
|
|
if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {
|
|
result.options = options;
|
|
}
|
|
if (annotation !== undefined) {
|
|
result.annotationId = annotation;
|
|
}
|
|
return result;
|
|
}
|
|
CreateFile.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate && candidate.kind === 'create' && Is.string(candidate.uri) && (candidate.options === undefined ||
|
|
((candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
|
|
}
|
|
CreateFile.is = is;
|
|
})(CreateFile || (CreateFile = {}));
|
|
var RenameFile;
|
|
(function (RenameFile) {
|
|
function create(oldUri, newUri, options, annotation) {
|
|
var result = {
|
|
kind: 'rename',
|
|
oldUri: oldUri,
|
|
newUri: newUri
|
|
};
|
|
if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {
|
|
result.options = options;
|
|
}
|
|
if (annotation !== undefined) {
|
|
result.annotationId = annotation;
|
|
}
|
|
return result;
|
|
}
|
|
RenameFile.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate && candidate.kind === 'rename' && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === undefined ||
|
|
((candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
|
|
}
|
|
RenameFile.is = is;
|
|
})(RenameFile || (RenameFile = {}));
|
|
var DeleteFile;
|
|
(function (DeleteFile) {
|
|
function create(uri, options, annotation) {
|
|
var result = {
|
|
kind: 'delete',
|
|
uri: uri
|
|
};
|
|
if (options !== undefined && (options.recursive !== undefined || options.ignoreIfNotExists !== undefined)) {
|
|
result.options = options;
|
|
}
|
|
if (annotation !== undefined) {
|
|
result.annotationId = annotation;
|
|
}
|
|
return result;
|
|
}
|
|
DeleteFile.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate && candidate.kind === 'delete' && Is.string(candidate.uri) && (candidate.options === undefined ||
|
|
((candidate.options.recursive === undefined || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === undefined || Is.boolean(candidate.options.ignoreIfNotExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
|
|
}
|
|
DeleteFile.is = is;
|
|
})(DeleteFile || (DeleteFile = {}));
|
|
var WorkspaceEdit;
|
|
(function (WorkspaceEdit) {
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate &&
|
|
(candidate.changes !== undefined || candidate.documentChanges !== undefined) &&
|
|
(candidate.documentChanges === undefined || 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);
|
|
}
|
|
}));
|
|
}
|
|
WorkspaceEdit.is = is;
|
|
})(WorkspaceEdit || (WorkspaceEdit = {}));
|
|
var TextEditChangeImpl = /** @class */ (function () {
|
|
function TextEditChangeImpl(edits, changeAnnotations) {
|
|
this.edits = edits;
|
|
this.changeAnnotations = changeAnnotations;
|
|
}
|
|
TextEditChangeImpl.prototype.insert = function (position, newText, annotation) {
|
|
var edit;
|
|
var id;
|
|
if (annotation === undefined) {
|
|
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 !== undefined) {
|
|
return id;
|
|
}
|
|
};
|
|
TextEditChangeImpl.prototype.replace = function (range, newText, annotation) {
|
|
var edit;
|
|
var id;
|
|
if (annotation === undefined) {
|
|
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 !== undefined) {
|
|
return id;
|
|
}
|
|
};
|
|
TextEditChangeImpl.prototype.delete = function (range, annotation) {
|
|
var edit;
|
|
var id;
|
|
if (annotation === undefined) {
|
|
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 !== undefined) {
|
|
return id;
|
|
}
|
|
};
|
|
TextEditChangeImpl.prototype.add = function (edit) {
|
|
this.edits.push(edit);
|
|
};
|
|
TextEditChangeImpl.prototype.all = function () {
|
|
return this.edits;
|
|
};
|
|
TextEditChangeImpl.prototype.clear = function () {
|
|
this.edits.splice(0, this.edits.length);
|
|
};
|
|
TextEditChangeImpl.prototype.assertChangeAnnotations = function (value) {
|
|
if (value === undefined) {
|
|
throw new Error("Text edit change is not configured to manage change annotations.");
|
|
}
|
|
};
|
|
return TextEditChangeImpl;
|
|
}());
|
|
/**
|
|
* A helper class
|
|
*/
|
|
var ChangeAnnotations = /** @class */ (function () {
|
|
function ChangeAnnotations(annotations) {
|
|
this._annotations = annotations === undefined ? Object.create(null) : annotations;
|
|
this._counter = 0;
|
|
this._size = 0;
|
|
}
|
|
ChangeAnnotations.prototype.all = function () {
|
|
return this._annotations;
|
|
};
|
|
Object.defineProperty(ChangeAnnotations.prototype, "size", {
|
|
get: function () {
|
|
return this._size;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
ChangeAnnotations.prototype.manage = function (idOrAnnotation, annotation) {
|
|
var id;
|
|
if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
|
|
id = idOrAnnotation;
|
|
}
|
|
else {
|
|
id = this.nextId();
|
|
annotation = idOrAnnotation;
|
|
}
|
|
if (this._annotations[id] !== undefined) {
|
|
throw new Error("Id ".concat(id, " is already in use."));
|
|
}
|
|
if (annotation === undefined) {
|
|
throw new Error("No annotation provided for id ".concat(id));
|
|
}
|
|
this._annotations[id] = annotation;
|
|
this._size++;
|
|
return id;
|
|
};
|
|
ChangeAnnotations.prototype.nextId = function () {
|
|
this._counter++;
|
|
return this._counter.toString();
|
|
};
|
|
return ChangeAnnotations;
|
|
}());
|
|
/**
|
|
* A workspace change helps constructing changes to a workspace.
|
|
*/
|
|
var WorkspaceChange = /** @class */ (function () {
|
|
function WorkspaceChange(workspaceEdit) {
|
|
var _this = this;
|
|
this._textEditChanges = Object.create(null);
|
|
if (workspaceEdit !== undefined) {
|
|
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(WorkspaceChange.prototype, "edit", {
|
|
/**
|
|
* Returns the underlying {@link WorkspaceEdit} literal
|
|
* use to be returned from a workspace edit operation like rename.
|
|
*/
|
|
get: function () {
|
|
this.initDocumentChanges();
|
|
if (this._changeAnnotations !== undefined) {
|
|
if (this._changeAnnotations.size === 0) {
|
|
this._workspaceEdit.changeAnnotations = undefined;
|
|
}
|
|
else {
|
|
this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
|
|
}
|
|
}
|
|
return this._workspaceEdit;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
WorkspaceChange.prototype.getTextEditChange = function (key) {
|
|
if (OptionalVersionedTextDocumentIdentifier.is(key)) {
|
|
this.initDocumentChanges();
|
|
if (this._workspaceEdit.documentChanges === undefined) {
|
|
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: textDocument,
|
|
edits: 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 === undefined) {
|
|
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;
|
|
}
|
|
};
|
|
WorkspaceChange.prototype.initDocumentChanges = function () {
|
|
if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {
|
|
this._changeAnnotations = new ChangeAnnotations();
|
|
this._workspaceEdit.documentChanges = [];
|
|
this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
|
|
}
|
|
};
|
|
WorkspaceChange.prototype.initChanges = function () {
|
|
if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {
|
|
this._workspaceEdit.changes = Object.create(null);
|
|
}
|
|
};
|
|
WorkspaceChange.prototype.createFile = function (uri, optionsOrAnnotation, options) {
|
|
this.initDocumentChanges();
|
|
if (this._workspaceEdit.documentChanges === undefined) {
|
|
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 === undefined) {
|
|
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 !== undefined) {
|
|
return id;
|
|
}
|
|
};
|
|
WorkspaceChange.prototype.renameFile = function (oldUri, newUri, optionsOrAnnotation, options) {
|
|
this.initDocumentChanges();
|
|
if (this._workspaceEdit.documentChanges === undefined) {
|
|
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 === undefined) {
|
|
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 !== undefined) {
|
|
return id;
|
|
}
|
|
};
|
|
WorkspaceChange.prototype.deleteFile = function (uri, optionsOrAnnotation, options) {
|
|
this.initDocumentChanges();
|
|
if (this._workspaceEdit.documentChanges === undefined) {
|
|
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 === undefined) {
|
|
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 !== undefined) {
|
|
return id;
|
|
}
|
|
};
|
|
return WorkspaceChange;
|
|
}());
|
|
|
|
/**
|
|
* The TextDocumentIdentifier namespace provides helper functions to work with
|
|
* {@link TextDocumentIdentifier} literals.
|
|
*/
|
|
var TextDocumentIdentifier;
|
|
(function (TextDocumentIdentifier) {
|
|
/**
|
|
* Creates a new TextDocumentIdentifier literal.
|
|
* @param uri The document's uri.
|
|
*/
|
|
function create(uri) {
|
|
return { uri: uri };
|
|
}
|
|
TextDocumentIdentifier.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link TextDocumentIdentifier} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Is.string(candidate.uri);
|
|
}
|
|
TextDocumentIdentifier.is = is;
|
|
})(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
|
|
/**
|
|
* The VersionedTextDocumentIdentifier namespace provides helper functions to work with
|
|
* {@link VersionedTextDocumentIdentifier} literals.
|
|
*/
|
|
var VersionedTextDocumentIdentifier;
|
|
(function (VersionedTextDocumentIdentifier) {
|
|
/**
|
|
* Creates a new VersionedTextDocumentIdentifier literal.
|
|
* @param uri The document's uri.
|
|
* @param version The document's version.
|
|
*/
|
|
function create(uri, version) {
|
|
return { uri: uri, version: version };
|
|
}
|
|
VersionedTextDocumentIdentifier.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link VersionedTextDocumentIdentifier} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
|
|
}
|
|
VersionedTextDocumentIdentifier.is = is;
|
|
})(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
|
|
/**
|
|
* The OptionalVersionedTextDocumentIdentifier namespace provides helper functions to work with
|
|
* {@link OptionalVersionedTextDocumentIdentifier} literals.
|
|
*/
|
|
var OptionalVersionedTextDocumentIdentifier;
|
|
(function (OptionalVersionedTextDocumentIdentifier) {
|
|
/**
|
|
* Creates a new OptionalVersionedTextDocumentIdentifier literal.
|
|
* @param uri The document's uri.
|
|
* @param version The document's version.
|
|
*/
|
|
function create(uri, version) {
|
|
return { uri: uri, version: version };
|
|
}
|
|
OptionalVersionedTextDocumentIdentifier.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link OptionalVersionedTextDocumentIdentifier} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
|
|
}
|
|
OptionalVersionedTextDocumentIdentifier.is = is;
|
|
})(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
|
|
/**
|
|
* The TextDocumentItem namespace provides helper functions to work with
|
|
* {@link TextDocumentItem} literals.
|
|
*/
|
|
var TextDocumentItem;
|
|
(function (TextDocumentItem) {
|
|
/**
|
|
* Creates a new TextDocumentItem literal.
|
|
* @param uri The document's uri.
|
|
* @param languageId The document's language identifier.
|
|
* @param version The document's version number.
|
|
* @param text The document's text.
|
|
*/
|
|
function create(uri, languageId, version, text) {
|
|
return { uri: uri, languageId: languageId, version: version, text: text };
|
|
}
|
|
TextDocumentItem.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link TextDocumentItem} interface.
|
|
*/
|
|
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);
|
|
}
|
|
TextDocumentItem.is = is;
|
|
})(TextDocumentItem || (TextDocumentItem = {}));
|
|
/**
|
|
* Describes the content type that a client supports in various
|
|
* result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
|
|
*
|
|
* Please note that `MarkupKinds` must not start with a `$`. This kinds
|
|
* are reserved for internal usage.
|
|
*/
|
|
var MarkupKind;
|
|
(function (MarkupKind) {
|
|
/**
|
|
* Plain text is supported as a content format
|
|
*/
|
|
MarkupKind.PlainText = 'plaintext';
|
|
/**
|
|
* Markdown is supported as a content format
|
|
*/
|
|
MarkupKind.Markdown = 'markdown';
|
|
/**
|
|
* Checks whether the given value is a value of the {@link MarkupKind} type.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown;
|
|
}
|
|
MarkupKind.is = is;
|
|
})(MarkupKind || (MarkupKind = {}));
|
|
var MarkupContent;
|
|
(function (MarkupContent) {
|
|
/**
|
|
* Checks whether the given value conforms to the {@link MarkupContent} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
|
|
}
|
|
MarkupContent.is = is;
|
|
})(MarkupContent || (MarkupContent = {}));
|
|
/**
|
|
* The kind of a completion entry.
|
|
*/
|
|
var CompletionItemKind;
|
|
(function (CompletionItemKind) {
|
|
CompletionItemKind.Text = 1;
|
|
CompletionItemKind.Method = 2;
|
|
CompletionItemKind.Function = 3;
|
|
CompletionItemKind.Constructor = 4;
|
|
CompletionItemKind.Field = 5;
|
|
CompletionItemKind.Variable = 6;
|
|
CompletionItemKind.Class = 7;
|
|
CompletionItemKind.Interface = 8;
|
|
CompletionItemKind.Module = 9;
|
|
CompletionItemKind.Property = 10;
|
|
CompletionItemKind.Unit = 11;
|
|
CompletionItemKind.Value = 12;
|
|
CompletionItemKind.Enum = 13;
|
|
CompletionItemKind.Keyword = 14;
|
|
CompletionItemKind.Snippet = 15;
|
|
CompletionItemKind.Color = 16;
|
|
CompletionItemKind.File = 17;
|
|
CompletionItemKind.Reference = 18;
|
|
CompletionItemKind.Folder = 19;
|
|
CompletionItemKind.EnumMember = 20;
|
|
CompletionItemKind.Constant = 21;
|
|
CompletionItemKind.Struct = 22;
|
|
CompletionItemKind.Event = 23;
|
|
CompletionItemKind.Operator = 24;
|
|
CompletionItemKind.TypeParameter = 25;
|
|
})(CompletionItemKind || (CompletionItemKind = {}));
|
|
/**
|
|
* Defines whether the insert text in a completion item should be interpreted as
|
|
* plain text or a snippet.
|
|
*/
|
|
var InsertTextFormat;
|
|
(function (InsertTextFormat) {
|
|
/**
|
|
* The primary text to be inserted is treated as a plain string.
|
|
*/
|
|
InsertTextFormat.PlainText = 1;
|
|
/**
|
|
* The primary text to be inserted is treated as a snippet.
|
|
*
|
|
* A snippet can define tab stops and placeholders with `$1`, `$2`
|
|
* and `${3:foo}`. `$0` defines the final tab stop, it defaults to
|
|
* the end of the snippet. Placeholders with equal identifiers are linked,
|
|
* that is typing in one will update others too.
|
|
*
|
|
* See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax
|
|
*/
|
|
InsertTextFormat.Snippet = 2;
|
|
})(InsertTextFormat || (InsertTextFormat = {}));
|
|
/**
|
|
* Completion item tags are extra annotations that tweak the rendering of a completion
|
|
* item.
|
|
*
|
|
* @since 3.15.0
|
|
*/
|
|
var CompletionItemTag;
|
|
(function (CompletionItemTag) {
|
|
/**
|
|
* Render a completion as obsolete, usually using a strike-out.
|
|
*/
|
|
CompletionItemTag.Deprecated = 1;
|
|
})(CompletionItemTag || (CompletionItemTag = {}));
|
|
/**
|
|
* The InsertReplaceEdit namespace provides functions to deal with insert / replace edits.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var InsertReplaceEdit;
|
|
(function (InsertReplaceEdit) {
|
|
/**
|
|
* Creates a new insert / replace edit
|
|
*/
|
|
function create(newText, insert, replace) {
|
|
return { newText: newText, insert: insert, replace: replace };
|
|
}
|
|
InsertReplaceEdit.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link InsertReplaceEdit} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);
|
|
}
|
|
InsertReplaceEdit.is = is;
|
|
})(InsertReplaceEdit || (InsertReplaceEdit = {}));
|
|
/**
|
|
* How whitespace and indentation is handled during completion
|
|
* item insertion.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var InsertTextMode;
|
|
(function (InsertTextMode) {
|
|
/**
|
|
* The insertion or replace strings is taken as it is. If the
|
|
* value is multi line the lines below the cursor will be
|
|
* inserted using the indentation defined in the string value.
|
|
* The client will not apply any kind of adjustments to the
|
|
* string.
|
|
*/
|
|
InsertTextMode.asIs = 1;
|
|
/**
|
|
* The editor adjusts leading whitespace of new lines so that
|
|
* they match the indentation up to the cursor of the line for
|
|
* which the item is accepted.
|
|
*
|
|
* Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a
|
|
* multi line completion item is indented using 2 tabs and all
|
|
* following lines inserted will be indented using 2 tabs as well.
|
|
*/
|
|
InsertTextMode.adjustIndentation = 2;
|
|
})(InsertTextMode || (InsertTextMode = {}));
|
|
var CompletionItemLabelDetails;
|
|
(function (CompletionItemLabelDetails) {
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate && (Is.string(candidate.detail) || candidate.detail === undefined) &&
|
|
(Is.string(candidate.description) || candidate.description === undefined);
|
|
}
|
|
CompletionItemLabelDetails.is = is;
|
|
})(CompletionItemLabelDetails || (CompletionItemLabelDetails = {}));
|
|
/**
|
|
* The CompletionItem namespace provides functions to deal with
|
|
* completion items.
|
|
*/
|
|
var CompletionItem;
|
|
(function (CompletionItem) {
|
|
/**
|
|
* Create a completion item and seed it with a label.
|
|
* @param label The completion item's label
|
|
*/
|
|
function create(label) {
|
|
return { label: label };
|
|
}
|
|
CompletionItem.create = create;
|
|
})(CompletionItem || (CompletionItem = {}));
|
|
/**
|
|
* The CompletionList namespace provides functions to deal with
|
|
* completion lists.
|
|
*/
|
|
var CompletionList;
|
|
(function (CompletionList) {
|
|
/**
|
|
* Creates a new completion list.
|
|
*
|
|
* @param items The completion items.
|
|
* @param isIncomplete The list is not complete.
|
|
*/
|
|
function create(items, isIncomplete) {
|
|
return { items: items ? items : [], isIncomplete: !!isIncomplete };
|
|
}
|
|
CompletionList.create = create;
|
|
})(CompletionList || (CompletionList = {}));
|
|
var MarkedString;
|
|
(function (MarkedString) {
|
|
/**
|
|
* Creates a marked string from plain text.
|
|
*
|
|
* @param plainText The plain text.
|
|
*/
|
|
function fromPlainText(plainText) {
|
|
return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&'); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
|
|
}
|
|
MarkedString.fromPlainText = fromPlainText;
|
|
/**
|
|
* Checks whether the given value conforms to the {@link MarkedString} type.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.string(candidate) || (Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value));
|
|
}
|
|
MarkedString.is = is;
|
|
})(MarkedString || (MarkedString = {}));
|
|
var Hover;
|
|
(function (Hover) {
|
|
/**
|
|
* Checks whether the given value conforms to the {@link Hover} interface.
|
|
*/
|
|
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 === undefined || Range.is(value.range));
|
|
}
|
|
Hover.is = is;
|
|
})(Hover || (Hover = {}));
|
|
/**
|
|
* The ParameterInformation namespace provides helper functions to work with
|
|
* {@link ParameterInformation} literals.
|
|
*/
|
|
var ParameterInformation;
|
|
(function (ParameterInformation) {
|
|
/**
|
|
* Creates a new parameter information literal.
|
|
*
|
|
* @param label A label string.
|
|
* @param documentation A doc string.
|
|
*/
|
|
function create(label, documentation) {
|
|
return documentation ? { label: label, documentation: documentation } : { label: label };
|
|
}
|
|
ParameterInformation.create = create;
|
|
})(ParameterInformation || (ParameterInformation = {}));
|
|
/**
|
|
* The SignatureInformation namespace provides helper functions to work with
|
|
* {@link SignatureInformation} literals.
|
|
*/
|
|
var SignatureInformation;
|
|
(function (SignatureInformation) {
|
|
function create(label, documentation) {
|
|
var parameters = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
parameters[_i - 2] = arguments[_i];
|
|
}
|
|
var result = { label: label };
|
|
if (Is.defined(documentation)) {
|
|
result.documentation = documentation;
|
|
}
|
|
if (Is.defined(parameters)) {
|
|
result.parameters = parameters;
|
|
}
|
|
else {
|
|
result.parameters = [];
|
|
}
|
|
return result;
|
|
}
|
|
SignatureInformation.create = create;
|
|
})(SignatureInformation || (SignatureInformation = {}));
|
|
/**
|
|
* A document highlight kind.
|
|
*/
|
|
var DocumentHighlightKind;
|
|
(function (DocumentHighlightKind) {
|
|
/**
|
|
* A textual occurrence.
|
|
*/
|
|
DocumentHighlightKind.Text = 1;
|
|
/**
|
|
* Read-access of a symbol, like reading a variable.
|
|
*/
|
|
DocumentHighlightKind.Read = 2;
|
|
/**
|
|
* Write-access of a symbol, like writing to a variable.
|
|
*/
|
|
DocumentHighlightKind.Write = 3;
|
|
})(DocumentHighlightKind || (DocumentHighlightKind = {}));
|
|
/**
|
|
* DocumentHighlight namespace to provide helper functions to work with
|
|
* {@link DocumentHighlight} literals.
|
|
*/
|
|
var DocumentHighlight;
|
|
(function (DocumentHighlight) {
|
|
/**
|
|
* Create a DocumentHighlight object.
|
|
* @param range The range the highlight applies to.
|
|
* @param kind The highlight kind
|
|
*/
|
|
function create(range, kind) {
|
|
var result = { range: range };
|
|
if (Is.number(kind)) {
|
|
result.kind = kind;
|
|
}
|
|
return result;
|
|
}
|
|
DocumentHighlight.create = create;
|
|
})(DocumentHighlight || (DocumentHighlight = {}));
|
|
/**
|
|
* A symbol kind.
|
|
*/
|
|
var SymbolKind;
|
|
(function (SymbolKind) {
|
|
SymbolKind.File = 1;
|
|
SymbolKind.Module = 2;
|
|
SymbolKind.Namespace = 3;
|
|
SymbolKind.Package = 4;
|
|
SymbolKind.Class = 5;
|
|
SymbolKind.Method = 6;
|
|
SymbolKind.Property = 7;
|
|
SymbolKind.Field = 8;
|
|
SymbolKind.Constructor = 9;
|
|
SymbolKind.Enum = 10;
|
|
SymbolKind.Interface = 11;
|
|
SymbolKind.Function = 12;
|
|
SymbolKind.Variable = 13;
|
|
SymbolKind.Constant = 14;
|
|
SymbolKind.String = 15;
|
|
SymbolKind.Number = 16;
|
|
SymbolKind.Boolean = 17;
|
|
SymbolKind.Array = 18;
|
|
SymbolKind.Object = 19;
|
|
SymbolKind.Key = 20;
|
|
SymbolKind.Null = 21;
|
|
SymbolKind.EnumMember = 22;
|
|
SymbolKind.Struct = 23;
|
|
SymbolKind.Event = 24;
|
|
SymbolKind.Operator = 25;
|
|
SymbolKind.TypeParameter = 26;
|
|
})(SymbolKind || (SymbolKind = {}));
|
|
/**
|
|
* Symbol tags are extra annotations that tweak the rendering of a symbol.
|
|
*
|
|
* @since 3.16
|
|
*/
|
|
var SymbolTag;
|
|
(function (SymbolTag) {
|
|
/**
|
|
* Render a symbol as obsolete, usually using a strike-out.
|
|
*/
|
|
SymbolTag.Deprecated = 1;
|
|
})(SymbolTag || (SymbolTag = {}));
|
|
var SymbolInformation;
|
|
(function (SymbolInformation) {
|
|
/**
|
|
* Creates a new symbol information literal.
|
|
*
|
|
* @param name The name of the symbol.
|
|
* @param kind The kind of the symbol.
|
|
* @param range The range of the location of the symbol.
|
|
* @param uri The resource of the location of symbol.
|
|
* @param containerName The name of the symbol containing the symbol.
|
|
*/
|
|
function create(name, kind, range, uri, containerName) {
|
|
var result = {
|
|
name: name,
|
|
kind: kind,
|
|
location: { uri: uri, range: range }
|
|
};
|
|
if (containerName) {
|
|
result.containerName = containerName;
|
|
}
|
|
return result;
|
|
}
|
|
SymbolInformation.create = create;
|
|
})(SymbolInformation || (SymbolInformation = {}));
|
|
var WorkspaceSymbol;
|
|
(function (WorkspaceSymbol) {
|
|
/**
|
|
* Create a new workspace symbol.
|
|
*
|
|
* @param name The name of the symbol.
|
|
* @param kind The kind of the symbol.
|
|
* @param uri The resource of the location of the symbol.
|
|
* @param range An options range of the location.
|
|
* @returns A WorkspaceSymbol.
|
|
*/
|
|
function create(name, kind, uri, range) {
|
|
return range !== undefined
|
|
? { name: name, kind: kind, location: { uri: uri, range: range } }
|
|
: { name: name, kind: kind, location: { uri: uri } };
|
|
}
|
|
WorkspaceSymbol.create = create;
|
|
})(WorkspaceSymbol || (WorkspaceSymbol = {}));
|
|
var DocumentSymbol;
|
|
(function (DocumentSymbol) {
|
|
/**
|
|
* Creates a new symbol information literal.
|
|
*
|
|
* @param name The name of the symbol.
|
|
* @param detail The detail of the symbol.
|
|
* @param kind The kind of the symbol.
|
|
* @param range The range of the symbol.
|
|
* @param selectionRange The selectionRange of the symbol.
|
|
* @param children Children of the symbol.
|
|
*/
|
|
function create(name, detail, kind, range, selectionRange, children) {
|
|
var result = {
|
|
name: name,
|
|
detail: detail,
|
|
kind: kind,
|
|
range: range,
|
|
selectionRange: selectionRange
|
|
};
|
|
if (children !== undefined) {
|
|
result.children = children;
|
|
}
|
|
return result;
|
|
}
|
|
DocumentSymbol.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link DocumentSymbol} interface.
|
|
*/
|
|
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 === undefined || Is.string(candidate.detail)) &&
|
|
(candidate.deprecated === undefined || Is.boolean(candidate.deprecated)) &&
|
|
(candidate.children === undefined || Array.isArray(candidate.children)) &&
|
|
(candidate.tags === undefined || Array.isArray(candidate.tags));
|
|
}
|
|
DocumentSymbol.is = is;
|
|
})(DocumentSymbol || (DocumentSymbol = {}));
|
|
/**
|
|
* A set of predefined code action kinds
|
|
*/
|
|
var CodeActionKind;
|
|
(function (CodeActionKind) {
|
|
/**
|
|
* Empty kind.
|
|
*/
|
|
CodeActionKind.Empty = '';
|
|
/**
|
|
* Base kind for quickfix actions: 'quickfix'
|
|
*/
|
|
CodeActionKind.QuickFix = 'quickfix';
|
|
/**
|
|
* Base kind for refactoring actions: 'refactor'
|
|
*/
|
|
CodeActionKind.Refactor = 'refactor';
|
|
/**
|
|
* Base kind for refactoring extraction actions: 'refactor.extract'
|
|
*
|
|
* Example extract actions:
|
|
*
|
|
* - Extract method
|
|
* - Extract function
|
|
* - Extract variable
|
|
* - Extract interface from class
|
|
* - ...
|
|
*/
|
|
CodeActionKind.RefactorExtract = 'refactor.extract';
|
|
/**
|
|
* Base kind for refactoring inline actions: 'refactor.inline'
|
|
*
|
|
* Example inline actions:
|
|
*
|
|
* - Inline function
|
|
* - Inline variable
|
|
* - Inline constant
|
|
* - ...
|
|
*/
|
|
CodeActionKind.RefactorInline = 'refactor.inline';
|
|
/**
|
|
* Base kind for refactoring rewrite actions: 'refactor.rewrite'
|
|
*
|
|
* Example rewrite actions:
|
|
*
|
|
* - Convert JavaScript function to class
|
|
* - Add or remove parameter
|
|
* - Encapsulate field
|
|
* - Make method static
|
|
* - Move method to base class
|
|
* - ...
|
|
*/
|
|
CodeActionKind.RefactorRewrite = 'refactor.rewrite';
|
|
/**
|
|
* Base kind for source actions: `source`
|
|
*
|
|
* Source code actions apply to the entire file.
|
|
*/
|
|
CodeActionKind.Source = 'source';
|
|
/**
|
|
* Base kind for an organize imports source action: `source.organizeImports`
|
|
*/
|
|
CodeActionKind.SourceOrganizeImports = 'source.organizeImports';
|
|
/**
|
|
* Base kind for auto-fix source actions: `source.fixAll`.
|
|
*
|
|
* Fix all actions automatically fix errors that have a clear fix that do not require user input.
|
|
* They should not suppress errors or perform unsafe fixes such as generating new types or classes.
|
|
*
|
|
* @since 3.15.0
|
|
*/
|
|
CodeActionKind.SourceFixAll = 'source.fixAll';
|
|
})(CodeActionKind || (CodeActionKind = {}));
|
|
/**
|
|
* The reason why code actions were requested.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var CodeActionTriggerKind;
|
|
(function (CodeActionTriggerKind) {
|
|
/**
|
|
* Code actions were explicitly requested by the user or by an extension.
|
|
*/
|
|
CodeActionTriggerKind.Invoked = 1;
|
|
/**
|
|
* Code actions were requested automatically.
|
|
*
|
|
* This typically happens when current selection in a file changes, but can
|
|
* also be triggered when file content changes.
|
|
*/
|
|
CodeActionTriggerKind.Automatic = 2;
|
|
})(CodeActionTriggerKind || (CodeActionTriggerKind = {}));
|
|
/**
|
|
* The CodeActionContext namespace provides helper functions to work with
|
|
* {@link CodeActionContext} literals.
|
|
*/
|
|
var CodeActionContext;
|
|
(function (CodeActionContext) {
|
|
/**
|
|
* Creates a new CodeActionContext literal.
|
|
*/
|
|
function create(diagnostics, only, triggerKind) {
|
|
var result = { diagnostics: diagnostics };
|
|
if (only !== undefined && only !== null) {
|
|
result.only = only;
|
|
}
|
|
if (triggerKind !== undefined && triggerKind !== null) {
|
|
result.triggerKind = triggerKind;
|
|
}
|
|
return result;
|
|
}
|
|
CodeActionContext.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link CodeActionContext} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is)
|
|
&& (candidate.only === undefined || Is.typedArray(candidate.only, Is.string))
|
|
&& (candidate.triggerKind === undefined || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
|
|
}
|
|
CodeActionContext.is = is;
|
|
})(CodeActionContext || (CodeActionContext = {}));
|
|
var CodeAction;
|
|
(function (CodeAction) {
|
|
function create(title, kindOrCommandOrEdit, kind) {
|
|
var result = { title: 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 !== undefined) {
|
|
result.kind = kind;
|
|
}
|
|
return result;
|
|
}
|
|
CodeAction.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate && Is.string(candidate.title) &&
|
|
(candidate.diagnostics === undefined || Is.typedArray(candidate.diagnostics, Diagnostic.is)) &&
|
|
(candidate.kind === undefined || Is.string(candidate.kind)) &&
|
|
(candidate.edit !== undefined || candidate.command !== undefined) &&
|
|
(candidate.command === undefined || Command.is(candidate.command)) &&
|
|
(candidate.isPreferred === undefined || Is.boolean(candidate.isPreferred)) &&
|
|
(candidate.edit === undefined || WorkspaceEdit.is(candidate.edit));
|
|
}
|
|
CodeAction.is = is;
|
|
})(CodeAction || (CodeAction = {}));
|
|
/**
|
|
* The CodeLens namespace provides helper functions to work with
|
|
* {@link CodeLens} literals.
|
|
*/
|
|
var CodeLens;
|
|
(function (CodeLens) {
|
|
/**
|
|
* Creates a new CodeLens literal.
|
|
*/
|
|
function create(range, data) {
|
|
var result = { range: range };
|
|
if (Is.defined(data)) {
|
|
result.data = data;
|
|
}
|
|
return result;
|
|
}
|
|
CodeLens.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link CodeLens} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
|
|
}
|
|
CodeLens.is = is;
|
|
})(CodeLens || (CodeLens = {}));
|
|
/**
|
|
* The FormattingOptions namespace provides helper functions to work with
|
|
* {@link FormattingOptions} literals.
|
|
*/
|
|
var FormattingOptions;
|
|
(function (FormattingOptions) {
|
|
/**
|
|
* Creates a new FormattingOptions literal.
|
|
*/
|
|
function create(tabSize, insertSpaces) {
|
|
return { tabSize: tabSize, insertSpaces: insertSpaces };
|
|
}
|
|
FormattingOptions.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link FormattingOptions} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
|
|
}
|
|
FormattingOptions.is = is;
|
|
})(FormattingOptions || (FormattingOptions = {}));
|
|
/**
|
|
* The DocumentLink namespace provides helper functions to work with
|
|
* {@link DocumentLink} literals.
|
|
*/
|
|
var DocumentLink;
|
|
(function (DocumentLink) {
|
|
/**
|
|
* Creates a new DocumentLink literal.
|
|
*/
|
|
function create(range, target, data) {
|
|
return { range: range, target: target, data: data };
|
|
}
|
|
DocumentLink.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link DocumentLink} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
|
|
}
|
|
DocumentLink.is = is;
|
|
})(DocumentLink || (DocumentLink = {}));
|
|
/**
|
|
* The SelectionRange namespace provides helper function to work with
|
|
* SelectionRange literals.
|
|
*/
|
|
var SelectionRange;
|
|
(function (SelectionRange) {
|
|
/**
|
|
* Creates a new SelectionRange
|
|
* @param range the range.
|
|
* @param parent an optional parent.
|
|
*/
|
|
function create(range, parent) {
|
|
return { range: range, parent: parent };
|
|
}
|
|
SelectionRange.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent));
|
|
}
|
|
SelectionRange.is = is;
|
|
})(SelectionRange || (SelectionRange = {}));
|
|
/**
|
|
* A set of predefined token types. This set is not fixed
|
|
* an clients can specify additional token types via the
|
|
* corresponding client capabilities.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var SemanticTokenTypes;
|
|
(function (SemanticTokenTypes) {
|
|
SemanticTokenTypes["namespace"] = "namespace";
|
|
/**
|
|
* Represents a generic type. Acts as a fallback for types which can't be mapped to
|
|
* a specific type like class or enum.
|
|
*/
|
|
SemanticTokenTypes["type"] = "type";
|
|
SemanticTokenTypes["class"] = "class";
|
|
SemanticTokenTypes["enum"] = "enum";
|
|
SemanticTokenTypes["interface"] = "interface";
|
|
SemanticTokenTypes["struct"] = "struct";
|
|
SemanticTokenTypes["typeParameter"] = "typeParameter";
|
|
SemanticTokenTypes["parameter"] = "parameter";
|
|
SemanticTokenTypes["variable"] = "variable";
|
|
SemanticTokenTypes["property"] = "property";
|
|
SemanticTokenTypes["enumMember"] = "enumMember";
|
|
SemanticTokenTypes["event"] = "event";
|
|
SemanticTokenTypes["function"] = "function";
|
|
SemanticTokenTypes["method"] = "method";
|
|
SemanticTokenTypes["macro"] = "macro";
|
|
SemanticTokenTypes["keyword"] = "keyword";
|
|
SemanticTokenTypes["modifier"] = "modifier";
|
|
SemanticTokenTypes["comment"] = "comment";
|
|
SemanticTokenTypes["string"] = "string";
|
|
SemanticTokenTypes["number"] = "number";
|
|
SemanticTokenTypes["regexp"] = "regexp";
|
|
SemanticTokenTypes["operator"] = "operator";
|
|
/**
|
|
* @since 3.17.0
|
|
*/
|
|
SemanticTokenTypes["decorator"] = "decorator";
|
|
})(SemanticTokenTypes || (SemanticTokenTypes = {}));
|
|
/**
|
|
* A set of predefined token modifiers. This set is not fixed
|
|
* an clients can specify additional token types via the
|
|
* corresponding client capabilities.
|
|
*
|
|
* @since 3.16.0
|
|
*/
|
|
var SemanticTokenModifiers;
|
|
(function (SemanticTokenModifiers) {
|
|
SemanticTokenModifiers["declaration"] = "declaration";
|
|
SemanticTokenModifiers["definition"] = "definition";
|
|
SemanticTokenModifiers["readonly"] = "readonly";
|
|
SemanticTokenModifiers["static"] = "static";
|
|
SemanticTokenModifiers["deprecated"] = "deprecated";
|
|
SemanticTokenModifiers["abstract"] = "abstract";
|
|
SemanticTokenModifiers["async"] = "async";
|
|
SemanticTokenModifiers["modification"] = "modification";
|
|
SemanticTokenModifiers["documentation"] = "documentation";
|
|
SemanticTokenModifiers["defaultLibrary"] = "defaultLibrary";
|
|
})(SemanticTokenModifiers || (SemanticTokenModifiers = {}));
|
|
/**
|
|
* @since 3.16.0
|
|
*/
|
|
var SemanticTokens;
|
|
(function (SemanticTokens) {
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && (candidate.resultId === undefined || typeof candidate.resultId === 'string') &&
|
|
Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === 'number');
|
|
}
|
|
SemanticTokens.is = is;
|
|
})(SemanticTokens || (SemanticTokens = {}));
|
|
/**
|
|
* The InlineValueText namespace provides functions to deal with InlineValueTexts.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var InlineValueText;
|
|
(function (InlineValueText) {
|
|
/**
|
|
* Creates a new InlineValueText literal.
|
|
*/
|
|
function create(range, text) {
|
|
return { range: range, text: text };
|
|
}
|
|
InlineValueText.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.string(candidate.text);
|
|
}
|
|
InlineValueText.is = is;
|
|
})(InlineValueText || (InlineValueText = {}));
|
|
/**
|
|
* The InlineValueVariableLookup namespace provides functions to deal with InlineValueVariableLookups.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var InlineValueVariableLookup;
|
|
(function (InlineValueVariableLookup) {
|
|
/**
|
|
* Creates a new InlineValueText literal.
|
|
*/
|
|
function create(range, variableName, caseSensitiveLookup) {
|
|
return { range: range, variableName: variableName, caseSensitiveLookup: caseSensitiveLookup };
|
|
}
|
|
InlineValueVariableLookup.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup)
|
|
&& (Is.string(candidate.variableName) || candidate.variableName === undefined);
|
|
}
|
|
InlineValueVariableLookup.is = is;
|
|
})(InlineValueVariableLookup || (InlineValueVariableLookup = {}));
|
|
/**
|
|
* The InlineValueEvaluatableExpression namespace provides functions to deal with InlineValueEvaluatableExpression.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var InlineValueEvaluatableExpression;
|
|
(function (InlineValueEvaluatableExpression) {
|
|
/**
|
|
* Creates a new InlineValueEvaluatableExpression literal.
|
|
*/
|
|
function create(range, expression) {
|
|
return { range: range, expression: expression };
|
|
}
|
|
InlineValueEvaluatableExpression.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return candidate !== undefined && candidate !== null && Range.is(candidate.range)
|
|
&& (Is.string(candidate.expression) || candidate.expression === undefined);
|
|
}
|
|
InlineValueEvaluatableExpression.is = is;
|
|
})(InlineValueEvaluatableExpression || (InlineValueEvaluatableExpression = {}));
|
|
/**
|
|
* The InlineValueContext namespace provides helper functions to work with
|
|
* {@link InlineValueContext} literals.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var InlineValueContext;
|
|
(function (InlineValueContext) {
|
|
/**
|
|
* Creates a new InlineValueContext literal.
|
|
*/
|
|
function create(frameId, stoppedLocation) {
|
|
return { frameId: frameId, stoppedLocation: stoppedLocation };
|
|
}
|
|
InlineValueContext.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link InlineValueContext} interface.
|
|
*/
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.defined(candidate) && Range.is(value.stoppedLocation);
|
|
}
|
|
InlineValueContext.is = is;
|
|
})(InlineValueContext || (InlineValueContext = {}));
|
|
/**
|
|
* Inlay hint kinds.
|
|
*
|
|
* @since 3.17.0
|
|
*/
|
|
var InlayHintKind;
|
|
(function (InlayHintKind) {
|
|
/**
|
|
* An inlay hint that for a type annotation.
|
|
*/
|
|
InlayHintKind.Type = 1;
|
|
/**
|
|
* An inlay hint that is for a parameter.
|
|
*/
|
|
InlayHintKind.Parameter = 2;
|
|
function is(value) {
|
|
return value === 1 || value === 2;
|
|
}
|
|
InlayHintKind.is = is;
|
|
})(InlayHintKind || (InlayHintKind = {}));
|
|
var InlayHintLabelPart;
|
|
(function (InlayHintLabelPart) {
|
|
function create(value) {
|
|
return { value: value };
|
|
}
|
|
InlayHintLabelPart.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate)
|
|
&& (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip))
|
|
&& (candidate.location === undefined || Location.is(candidate.location))
|
|
&& (candidate.command === undefined || Command.is(candidate.command));
|
|
}
|
|
InlayHintLabelPart.is = is;
|
|
})(InlayHintLabelPart || (InlayHintLabelPart = {}));
|
|
var InlayHint;
|
|
(function (InlayHint) {
|
|
function create(position, label, kind) {
|
|
var result = { position: position, label: label };
|
|
if (kind !== undefined) {
|
|
result.kind = kind;
|
|
}
|
|
return result;
|
|
}
|
|
InlayHint.create = create;
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && Position.is(candidate.position)
|
|
&& (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is))
|
|
&& (candidate.kind === undefined || InlayHintKind.is(candidate.kind))
|
|
&& (candidate.textEdits === undefined) || Is.typedArray(candidate.textEdits, TextEdit.is)
|
|
&& (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip))
|
|
&& (candidate.paddingLeft === undefined || Is.boolean(candidate.paddingLeft))
|
|
&& (candidate.paddingRight === undefined || Is.boolean(candidate.paddingRight));
|
|
}
|
|
InlayHint.is = is;
|
|
})(InlayHint || (InlayHint = {}));
|
|
var WorkspaceFolder;
|
|
(function (WorkspaceFolder) {
|
|
function is(value) {
|
|
var candidate = value;
|
|
return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);
|
|
}
|
|
WorkspaceFolder.is = is;
|
|
})(WorkspaceFolder || (WorkspaceFolder = {}));
|
|
var EOL = ['\n', '\r\n', '\r'];
|
|
/**
|
|
* @deprecated Use the text document from the new vscode-languageserver-textdocument package.
|
|
*/
|
|
var TextDocument;
|
|
(function (TextDocument) {
|
|
/**
|
|
* Creates a new ITextDocument literal from the given uri and content.
|
|
* @param uri The document's uri.
|
|
* @param languageId The document's language Id.
|
|
* @param version The document's version.
|
|
* @param content The document's content.
|
|
*/
|
|
function create(uri, languageId, version, content) {
|
|
return new FullTextDocument(uri, languageId, version, content);
|
|
}
|
|
TextDocument.create = create;
|
|
/**
|
|
* Checks whether the given literal conforms to the {@link ITextDocument} interface.
|
|
*/
|
|
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;
|
|
}
|
|
TextDocument.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;
|
|
}
|
|
TextDocument.applyEdits = applyEdits;
|
|
function mergeSort(data, compare) {
|
|
if (data.length <= 1) {
|
|
// sorted
|
|
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) {
|
|
// smaller_equal -> take left to preserve order
|
|
data[i++] = left[leftIdx++];
|
|
}
|
|
else {
|
|
// greater -> take right
|
|
data[i++] = right[rightIdx++];
|
|
}
|
|
}
|
|
while (leftIdx < left.length) {
|
|
data[i++] = left[leftIdx++];
|
|
}
|
|
while (rightIdx < right.length) {
|
|
data[i++] = right[rightIdx++];
|
|
}
|
|
return data;
|
|
}
|
|
})(TextDocument || (TextDocument = {}));
|
|
/**
|
|
* @deprecated Use the text document from the new vscode-languageserver-textdocument package.
|
|
*/
|
|
var FullTextDocument = /** @class */ (function () {
|
|
function FullTextDocument(uri, languageId, version, content) {
|
|
this._uri = uri;
|
|
this._languageId = languageId;
|
|
this._version = version;
|
|
this._content = content;
|
|
this._lineOffsets = undefined;
|
|
}
|
|
Object.defineProperty(FullTextDocument.prototype, "uri", {
|
|
get: function () {
|
|
return this._uri;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(FullTextDocument.prototype, "languageId", {
|
|
get: function () {
|
|
return this._languageId;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(FullTextDocument.prototype, "version", {
|
|
get: function () {
|
|
return this._version;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
FullTextDocument.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;
|
|
};
|
|
FullTextDocument.prototype.update = function (event, version) {
|
|
this._content = event.text;
|
|
this._version = version;
|
|
this._lineOffsets = undefined;
|
|
};
|
|
FullTextDocument.prototype.getLineOffsets = function () {
|
|
if (this._lineOffsets === undefined) {
|
|
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;
|
|
};
|
|
FullTextDocument.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;
|
|
}
|
|
}
|
|
// low is the least x for which the line offset is larger than the current offset
|
|
// or array.length if no line offset is larger than the current offset
|
|
var line = low - 1;
|
|
return Position.create(line, offset - lineOffsets[line]);
|
|
};
|
|
FullTextDocument.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(FullTextDocument.prototype, "lineCount", {
|
|
get: function () {
|
|
return this.getLineOffsets().length;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return FullTextDocument;
|
|
}());
|
|
var Is;
|
|
(function (Is) {
|
|
var toString = Object.prototype.toString;
|
|
function defined(value) {
|
|
return typeof value !== 'undefined';
|
|
}
|
|
Is.defined = defined;
|
|
function undefined(value) {
|
|
return typeof value === 'undefined';
|
|
}
|
|
Is.undefined = undefined;
|
|
function boolean(value) {
|
|
return value === true || value === false;
|
|
}
|
|
Is.boolean = boolean;
|
|
function string(value) {
|
|
return toString.call(value) === '[object String]';
|
|
}
|
|
Is.string = string;
|
|
function number(value) {
|
|
return toString.call(value) === '[object Number]';
|
|
}
|
|
Is.number = number;
|
|
function numberRange(value, min, max) {
|
|
return toString.call(value) === '[object Number]' && min <= value && value <= max;
|
|
}
|
|
Is.numberRange = numberRange;
|
|
function integer(value) {
|
|
return toString.call(value) === '[object Number]' && -2147483648 <= value && value <= 2147483647;
|
|
}
|
|
Is.integer = integer;
|
|
function uinteger(value) {
|
|
return toString.call(value) === '[object Number]' && 0 <= value && value <= 2147483647;
|
|
}
|
|
Is.uinteger = uinteger;
|
|
function func(value) {
|
|
return toString.call(value) === '[object Function]';
|
|
}
|
|
Is.func = func;
|
|
function objectLiteral(value) {
|
|
// Strictly speaking class instances pass this check as well. Since the LSP
|
|
// doesn't use classes we ignore this for now. If we do we need to add something
|
|
// like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`
|
|
return value !== null && typeof value === 'object';
|
|
}
|
|
Is.objectLiteral = objectLiteral;
|
|
function typedArray(value, check) {
|
|
return Array.isArray(value) && value.every(check);
|
|
}
|
|
Is.typedArray = typedArray;
|
|
})(Is || (Is = {}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2730:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var forEach = __webpack_require__(705);
|
|
var availableTypedArrays = __webpack_require__(4834);
|
|
var callBind = __webpack_require__(8498);
|
|
var callBound = __webpack_require__(9818);
|
|
var gOPD = __webpack_require__(9336);
|
|
|
|
var $toString = callBound('Object.prototype.toString');
|
|
var hasToStringTag = __webpack_require__(1913)();
|
|
|
|
var g = typeof globalThis === 'undefined' ? __webpack_require__.g : globalThis;
|
|
var typedArrays = availableTypedArrays();
|
|
|
|
var $slice = callBound('String.prototype.slice');
|
|
var getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');
|
|
|
|
var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {
|
|
for (var i = 0; i < array.length; i += 1) {
|
|
if (array[i] === value) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
var cache = { __proto__: null };
|
|
if (hasToStringTag && gOPD && getPrototypeOf) {
|
|
forEach(typedArrays, function (typedArray) {
|
|
var arr = new g[typedArray]();
|
|
if (Symbol.toStringTag in arr) {
|
|
var proto = getPrototypeOf(arr);
|
|
var descriptor = gOPD(proto, Symbol.toStringTag);
|
|
if (!descriptor) {
|
|
var superProto = getPrototypeOf(proto);
|
|
descriptor = gOPD(superProto, Symbol.toStringTag);
|
|
}
|
|
cache['$' + typedArray] = callBind(descriptor.get);
|
|
}
|
|
});
|
|
} else {
|
|
forEach(typedArrays, function (typedArray) {
|
|
var arr = new g[typedArray]();
|
|
cache['$' + typedArray] = callBind(arr.slice);
|
|
});
|
|
}
|
|
|
|
var tryTypedArrays = function tryAllTypedArrays(value) {
|
|
var found = false;
|
|
forEach(cache, function (getter, typedArray) {
|
|
if (!found) {
|
|
try {
|
|
if ('$' + getter(value) === typedArray) {
|
|
found = $slice(typedArray, 1);
|
|
}
|
|
} catch (e) { /**/ }
|
|
}
|
|
});
|
|
return found;
|
|
};
|
|
|
|
var trySlices = function tryAllSlices(value) {
|
|
var found = false;
|
|
forEach(cache, function (getter, name) {
|
|
if (!found) {
|
|
try {
|
|
getter(value);
|
|
found = $slice(name, 1);
|
|
} catch (e) { /**/ }
|
|
}
|
|
});
|
|
return found;
|
|
};
|
|
|
|
module.exports = function whichTypedArray(value) {
|
|
if (!value || typeof value !== 'object') { return false; }
|
|
if (!hasToStringTag) {
|
|
var tag = $slice($toString(value), 8, -1);
|
|
if ($indexOf(typedArrays, tag) > -1) {
|
|
return tag;
|
|
}
|
|
if (tag !== 'Object') {
|
|
return false;
|
|
}
|
|
// node < 0.6 hits here on real Typed Arrays
|
|
return trySlices(value);
|
|
}
|
|
if (!gOPD) { return null; } // unknown engine
|
|
return tryTypedArrays(value);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4834:
|
|
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
|
|
|
|
var possibleNames = [
|
|
'BigInt64Array',
|
|
'BigUint64Array',
|
|
'Float32Array',
|
|
'Float64Array',
|
|
'Int16Array',
|
|
'Int32Array',
|
|
'Int8Array',
|
|
'Uint16Array',
|
|
'Uint32Array',
|
|
'Uint8Array',
|
|
'Uint8ClampedArray'
|
|
];
|
|
|
|
var g = typeof globalThis === 'undefined' ? __webpack_require__.g : globalThis;
|
|
|
|
module.exports = function availableTypedArrays() {
|
|
var out = [];
|
|
for (var i = 0; i < possibleNames.length; i++) {
|
|
if (typeof g[possibleNames[i]] === 'function') {
|
|
out[out.length] = possibleNames[i];
|
|
}
|
|
}
|
|
return out;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8041:
|
|
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
|
|
|
|
"use strict";
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ V: () => (/* binding */ TextDocument)
|
|
/* harmony export */ });
|
|
/* --------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
* ------------------------------------------------------------------------------------------ */
|
|
|
|
class FullTextDocument {
|
|
constructor(uri, languageId, version, content) {
|
|
this._uri = uri;
|
|
this._languageId = languageId;
|
|
this._version = version;
|
|
this._content = content;
|
|
this._lineOffsets = undefined;
|
|
}
|
|
get uri() {
|
|
return this._uri;
|
|
}
|
|
get languageId() {
|
|
return this._languageId;
|
|
}
|
|
get version() {
|
|
return this._version;
|
|
}
|
|
getText(range) {
|
|
if (range) {
|
|
const start = this.offsetAt(range.start);
|
|
const end = this.offsetAt(range.end);
|
|
return this._content.substring(start, end);
|
|
}
|
|
return this._content;
|
|
}
|
|
update(changes, version) {
|
|
for (const change of changes) {
|
|
if (FullTextDocument.isIncremental(change)) {
|
|
// makes sure start is before end
|
|
const range = getWellformedRange(change.range);
|
|
// update content
|
|
const startOffset = this.offsetAt(range.start);
|
|
const endOffset = this.offsetAt(range.end);
|
|
this._content = this._content.substring(0, startOffset) + change.text + this._content.substring(endOffset, this._content.length);
|
|
// update the offsets
|
|
const startLine = Math.max(range.start.line, 0);
|
|
const endLine = Math.max(range.end.line, 0);
|
|
let lineOffsets = this._lineOffsets;
|
|
const addedLineOffsets = computeLineOffsets(change.text, false, startOffset);
|
|
if (endLine - startLine === addedLineOffsets.length) {
|
|
for (let i = 0, len = addedLineOffsets.length; i < len; i++) {
|
|
lineOffsets[i + startLine + 1] = addedLineOffsets[i];
|
|
}
|
|
}
|
|
else {
|
|
if (addedLineOffsets.length < 10000) {
|
|
lineOffsets.splice(startLine + 1, endLine - startLine, ...addedLineOffsets);
|
|
}
|
|
else { // avoid too many arguments for splice
|
|
this._lineOffsets = lineOffsets = lineOffsets.slice(0, startLine + 1).concat(addedLineOffsets, lineOffsets.slice(endLine + 1));
|
|
}
|
|
}
|
|
const diff = change.text.length - (endOffset - startOffset);
|
|
if (diff !== 0) {
|
|
for (let i = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i < len; i++) {
|
|
lineOffsets[i] = lineOffsets[i] + diff;
|
|
}
|
|
}
|
|
}
|
|
else if (FullTextDocument.isFull(change)) {
|
|
this._content = change.text;
|
|
this._lineOffsets = undefined;
|
|
}
|
|
else {
|
|
throw new Error('Unknown change event received');
|
|
}
|
|
}
|
|
this._version = version;
|
|
}
|
|
getLineOffsets() {
|
|
if (this._lineOffsets === undefined) {
|
|
this._lineOffsets = computeLineOffsets(this._content, true);
|
|
}
|
|
return this._lineOffsets;
|
|
}
|
|
positionAt(offset) {
|
|
offset = Math.max(Math.min(offset, this._content.length), 0);
|
|
const lineOffsets = this.getLineOffsets();
|
|
let low = 0, high = lineOffsets.length;
|
|
if (high === 0) {
|
|
return { line: 0, character: offset };
|
|
}
|
|
while (low < high) {
|
|
const mid = Math.floor((low + high) / 2);
|
|
if (lineOffsets[mid] > offset) {
|
|
high = mid;
|
|
}
|
|
else {
|
|
low = mid + 1;
|
|
}
|
|
}
|
|
// low is the least x for which the line offset is larger than the current offset
|
|
// or array.length if no line offset is larger than the current offset
|
|
const line = low - 1;
|
|
offset = this.ensureBeforeEOL(offset, lineOffsets[line]);
|
|
return { line, character: offset - lineOffsets[line] };
|
|
}
|
|
offsetAt(position) {
|
|
const lineOffsets = this.getLineOffsets();
|
|
if (position.line >= lineOffsets.length) {
|
|
return this._content.length;
|
|
}
|
|
else if (position.line < 0) {
|
|
return 0;
|
|
}
|
|
const lineOffset = lineOffsets[position.line];
|
|
if (position.character <= 0) {
|
|
return lineOffset;
|
|
}
|
|
const nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;
|
|
const offset = Math.min(lineOffset + position.character, nextLineOffset);
|
|
return this.ensureBeforeEOL(offset, lineOffset);
|
|
}
|
|
ensureBeforeEOL(offset, lineOffset) {
|
|
while (offset > lineOffset && isEOL(this._content.charCodeAt(offset - 1))) {
|
|
offset--;
|
|
}
|
|
return offset;
|
|
}
|
|
get lineCount() {
|
|
return this.getLineOffsets().length;
|
|
}
|
|
static isIncremental(event) {
|
|
const candidate = event;
|
|
return candidate !== undefined && candidate !== null &&
|
|
typeof candidate.text === 'string' && candidate.range !== undefined &&
|
|
(candidate.rangeLength === undefined || typeof candidate.rangeLength === 'number');
|
|
}
|
|
static isFull(event) {
|
|
const candidate = event;
|
|
return candidate !== undefined && candidate !== null &&
|
|
typeof candidate.text === 'string' && candidate.range === undefined && candidate.rangeLength === undefined;
|
|
}
|
|
}
|
|
var TextDocument;
|
|
(function (TextDocument) {
|
|
/**
|
|
* Creates a new text document.
|
|
*
|
|
* @param uri The document's uri.
|
|
* @param languageId The document's language Id.
|
|
* @param version The document's initial version number.
|
|
* @param content The document's content.
|
|
*/
|
|
function create(uri, languageId, version, content) {
|
|
return new FullTextDocument(uri, languageId, version, content);
|
|
}
|
|
TextDocument.create = create;
|
|
/**
|
|
* Updates a TextDocument by modifying its content.
|
|
*
|
|
* @param document the document to update. Only documents created by TextDocument.create are valid inputs.
|
|
* @param changes the changes to apply to the document.
|
|
* @param version the changes version for the document.
|
|
* @returns The updated TextDocument. Note: That's the same document instance passed in as first parameter.
|
|
*
|
|
*/
|
|
function update(document, changes, version) {
|
|
if (document instanceof FullTextDocument) {
|
|
document.update(changes, version);
|
|
return document;
|
|
}
|
|
else {
|
|
throw new Error('TextDocument.update: document must be created by TextDocument.create');
|
|
}
|
|
}
|
|
TextDocument.update = update;
|
|
function applyEdits(document, edits) {
|
|
const text = document.getText();
|
|
const sortedEdits = mergeSort(edits.map(getWellformedEdit), (a, b) => {
|
|
const diff = a.range.start.line - b.range.start.line;
|
|
if (diff === 0) {
|
|
return a.range.start.character - b.range.start.character;
|
|
}
|
|
return diff;
|
|
});
|
|
let lastModifiedOffset = 0;
|
|
const spans = [];
|
|
for (const e of sortedEdits) {
|
|
const startOffset = document.offsetAt(e.range.start);
|
|
if (startOffset < lastModifiedOffset) {
|
|
throw new Error('Overlapping edit');
|
|
}
|
|
else if (startOffset > lastModifiedOffset) {
|
|
spans.push(text.substring(lastModifiedOffset, startOffset));
|
|
}
|
|
if (e.newText.length) {
|
|
spans.push(e.newText);
|
|
}
|
|
lastModifiedOffset = document.offsetAt(e.range.end);
|
|
}
|
|
spans.push(text.substr(lastModifiedOffset));
|
|
return spans.join('');
|
|
}
|
|
TextDocument.applyEdits = applyEdits;
|
|
})(TextDocument || (TextDocument = {}));
|
|
function mergeSort(data, compare) {
|
|
if (data.length <= 1) {
|
|
// sorted
|
|
return data;
|
|
}
|
|
const p = (data.length / 2) | 0;
|
|
const left = data.slice(0, p);
|
|
const right = data.slice(p);
|
|
mergeSort(left, compare);
|
|
mergeSort(right, compare);
|
|
let leftIdx = 0;
|
|
let rightIdx = 0;
|
|
let i = 0;
|
|
while (leftIdx < left.length && rightIdx < right.length) {
|
|
const ret = compare(left[leftIdx], right[rightIdx]);
|
|
if (ret <= 0) {
|
|
// smaller_equal -> take left to preserve order
|
|
data[i++] = left[leftIdx++];
|
|
}
|
|
else {
|
|
// greater -> take right
|
|
data[i++] = right[rightIdx++];
|
|
}
|
|
}
|
|
while (leftIdx < left.length) {
|
|
data[i++] = left[leftIdx++];
|
|
}
|
|
while (rightIdx < right.length) {
|
|
data[i++] = right[rightIdx++];
|
|
}
|
|
return data;
|
|
}
|
|
function computeLineOffsets(text, isAtLineStart, textOffset = 0) {
|
|
const result = isAtLineStart ? [textOffset] : [];
|
|
for (let i = 0; i < text.length; i++) {
|
|
const ch = text.charCodeAt(i);
|
|
if (isEOL(ch)) {
|
|
if (ch === 13 /* CharCode.CarriageReturn */ && i + 1 < text.length && text.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {
|
|
i++;
|
|
}
|
|
result.push(textOffset + i + 1);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function isEOL(char) {
|
|
return char === 13 /* CharCode.CarriageReturn */ || char === 10 /* CharCode.LineFeed */;
|
|
}
|
|
function getWellformedRange(range) {
|
|
const start = range.start;
|
|
const end = range.end;
|
|
if (start.line > end.line || (start.line === end.line && start.character > end.character)) {
|
|
return { start: end, end: start };
|
|
}
|
|
return range;
|
|
}
|
|
function getWellformedEdit(textEdit) {
|
|
const range = getWellformedRange(textEdit.range);
|
|
if (range !== textEdit.range) {
|
|
return { newText: textEdit.newText, range };
|
|
}
|
|
return textEdit;
|
|
}
|
|
|
|
|
|
/***/ })
|
|
|
|
/******/ });
|
|
/************************************************************************/
|
|
/******/ // The module cache
|
|
/******/ var __webpack_module_cache__ = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/ // Check if module is in cache
|
|
/******/ var cachedModule = __webpack_module_cache__[moduleId];
|
|
/******/ if (cachedModule !== undefined) {
|
|
/******/ return cachedModule.exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = __webpack_module_cache__[moduleId] = {
|
|
/******/ id: moduleId,
|
|
/******/ loaded: false,
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.loaded = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/************************************************************************/
|
|
/******/ /* webpack/runtime/compat get default export */
|
|
/******/ (() => {
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = (module) => {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ () => (module['default']) :
|
|
/******/ () => (module);
|
|
/******/ __webpack_require__.d(getter, { a: getter });
|
|
/******/ return getter;
|
|
/******/ };
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/define property getters */
|
|
/******/ (() => {
|
|
/******/ // define getter functions for harmony exports
|
|
/******/ __webpack_require__.d = (exports, definition) => {
|
|
/******/ for(var key in definition) {
|
|
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
|
|
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
|
|
/******/ }
|
|
/******/ }
|
|
/******/ };
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/global */
|
|
/******/ (() => {
|
|
/******/ __webpack_require__.g = (function() {
|
|
/******/ if (typeof globalThis === 'object') return globalThis;
|
|
/******/ try {
|
|
/******/ return this || new Function('return this')();
|
|
/******/ } catch (e) {
|
|
/******/ if (typeof window === 'object') return window;
|
|
/******/ }
|
|
/******/ })();
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/hasOwnProperty shorthand */
|
|
/******/ (() => {
|
|
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/make namespace object */
|
|
/******/ (() => {
|
|
/******/ // define __esModule on exports
|
|
/******/ __webpack_require__.r = (exports) => {
|
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
|
/******/ }
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
|
/******/ };
|
|
/******/ })();
|
|
/******/
|
|
/******/ /* webpack/runtime/node module decorator */
|
|
/******/ (() => {
|
|
/******/ __webpack_require__.nmd = (module) => {
|
|
/******/ module.paths = [];
|
|
/******/ if (!module.children) module.children = [];
|
|
/******/ return module;
|
|
/******/ };
|
|
/******/ })();
|
|
/******/
|
|
/************************************************************************/
|
|
var __webpack_exports__ = {};
|
|
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
|
|
(() => {
|
|
"use strict";
|
|
// ESM COMPAT FLAG
|
|
__webpack_require__.r(__webpack_exports__);
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
LuaService: () => (/* binding */ LuaService)
|
|
});
|
|
|
|
// EXTERNAL MODULE: ./src/services/base-service.ts
|
|
var base_service = __webpack_require__(2125);
|
|
// EXTERNAL MODULE: ../../node_modules/luaparse/luaparse.js
|
|
var luaparse = __webpack_require__(98);
|
|
// EXTERNAL MODULE: ../../node_modules/vscode-languageserver-protocol/lib/browser/main.js
|
|
var main = __webpack_require__(5501);
|
|
// EXTERNAL MODULE: ./src/utils.ts
|
|
var utils = __webpack_require__(7770);
|
|
;// CONCATENATED MODULE: ./src/ace/range-singleton.ts
|
|
function _define_property(obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
class AceRange {
|
|
static getConstructor(editor) {
|
|
if (!AceRange._instance && editor) {
|
|
AceRange._instance = editor.getSelectionRange().constructor;
|
|
}
|
|
return AceRange._instance;
|
|
}
|
|
}
|
|
_define_property(AceRange, "_instance", void 0);
|
|
|
|
;// CONCATENATED MODULE: ./src/type-converters/common-converters.ts
|
|
|
|
|
|
|
|
var common_converters_CommonConverter;
|
|
(function(CommonConverter) {
|
|
function normalizeRanges(completions) {
|
|
return completions && completions.map((el)=>{
|
|
if (el["range"]) {
|
|
el["range"] = toRange(el["range"]);
|
|
}
|
|
return el;
|
|
});
|
|
}
|
|
CommonConverter.normalizeRanges = normalizeRanges;
|
|
function cleanHtml(html) {
|
|
return html.replace(/<a\s/, "<a target='_blank' ");
|
|
}
|
|
CommonConverter.cleanHtml = cleanHtml;
|
|
function toRange(range) {
|
|
if (!range || !range.start || !range.end) {
|
|
return;
|
|
}
|
|
let Range = AceRange.getConstructor();
|
|
// @ts-ignore
|
|
return Range.fromPoints(range.start, range.end);
|
|
}
|
|
CommonConverter.toRange = toRange;
|
|
function convertKind(kind) {
|
|
switch(kind){
|
|
case "primitiveType":
|
|
case "keyword":
|
|
return main.CompletionItemKind.Keyword;
|
|
case "variable":
|
|
case "localVariable":
|
|
return main.CompletionItemKind.Variable;
|
|
case "memberVariable":
|
|
case "memberGetAccessor":
|
|
case "memberSetAccessor":
|
|
return main.CompletionItemKind.Field;
|
|
case "function":
|
|
case "memberFunction":
|
|
case "constructSignature":
|
|
case "callSignature":
|
|
case "indexSignature":
|
|
return main.CompletionItemKind.Function;
|
|
case "enum":
|
|
return main.CompletionItemKind.Enum;
|
|
case "module":
|
|
return main.CompletionItemKind.Module;
|
|
case "class":
|
|
return main.CompletionItemKind.Class;
|
|
case "interface":
|
|
return main.CompletionItemKind.Interface;
|
|
case "warning":
|
|
return main.CompletionItemKind.File;
|
|
}
|
|
return main.CompletionItemKind.Property;
|
|
}
|
|
CommonConverter.convertKind = convertKind;
|
|
function excludeByErrorMessage(diagnostics, errorMessagesToIgnore, fieldName = "message") {
|
|
if (!errorMessagesToIgnore) return diagnostics;
|
|
return diagnostics.filter((el)=>!(0,utils/* checkValueAgainstRegexpArray */.Tk)(el[fieldName], errorMessagesToIgnore));
|
|
}
|
|
CommonConverter.excludeByErrorMessage = excludeByErrorMessage;
|
|
})(common_converters_CommonConverter || (common_converters_CommonConverter = {}));
|
|
|
|
;// CONCATENATED MODULE: ./src/type-converters/lsp/lsp-converters.ts
|
|
|
|
|
|
|
|
|
|
function fromRange(range) {
|
|
return {
|
|
start: {
|
|
line: range.start.row,
|
|
character: range.start.column
|
|
},
|
|
end: {
|
|
line: range.end.row,
|
|
character: range.end.column
|
|
}
|
|
};
|
|
}
|
|
function rangeFromPositions(start, end) {
|
|
return {
|
|
start: start,
|
|
end: end
|
|
};
|
|
}
|
|
function toRange(range) {
|
|
return {
|
|
start: {
|
|
row: range.start.line,
|
|
column: range.start.character
|
|
},
|
|
end: {
|
|
row: range.end.line,
|
|
column: range.end.character
|
|
}
|
|
};
|
|
}
|
|
function fromPoint(point) {
|
|
return {
|
|
line: point.row,
|
|
character: point.column
|
|
};
|
|
}
|
|
function toPoint(position) {
|
|
return {
|
|
row: position.line,
|
|
column: position.character
|
|
};
|
|
}
|
|
function toAnnotations(diagnostics) {
|
|
var _diagnostics;
|
|
return (_diagnostics = diagnostics) === null || _diagnostics === void 0 ? void 0 : _diagnostics.map((el)=>{
|
|
return {
|
|
row: el.range.start.line,
|
|
column: el.range.start.character,
|
|
text: el.message,
|
|
type: el.severity === 1 ? "error" : el.severity === 2 ? "warning" : "info",
|
|
code: el.code
|
|
};
|
|
});
|
|
}
|
|
function fromAnnotations(annotations) {
|
|
var _annotations;
|
|
return (_annotations = annotations) === null || _annotations === void 0 ? void 0 : _annotations.map((el)=>{
|
|
return {
|
|
range: {
|
|
start: {
|
|
line: el.row,
|
|
character: el.column
|
|
},
|
|
end: {
|
|
line: el.row,
|
|
character: el.column
|
|
}
|
|
},
|
|
message: el.text,
|
|
severity: el.type === "error" ? 1 : el.type === "warning" ? 2 : 3,
|
|
code: el["code"]
|
|
};
|
|
});
|
|
}
|
|
function toCompletion(item) {
|
|
var _item_textEdit, _item_command;
|
|
let itemKind = item.kind;
|
|
let kind = itemKind ? Object.keys(CompletionItemKind)[Object.values(CompletionItemKind).indexOf(itemKind)] : undefined;
|
|
var _item_textEdit_newText, _ref;
|
|
let text = (_ref = (_item_textEdit_newText = (_item_textEdit = item.textEdit) === null || _item_textEdit === void 0 ? void 0 : _item_textEdit.newText) !== null && _item_textEdit_newText !== void 0 ? _item_textEdit_newText : item.insertText) !== null && _ref !== void 0 ? _ref : item.label;
|
|
let filterText;
|
|
// filtering would happen on ace editor side
|
|
//TODO: if filtering and sorting are on server side, we should disable FilteredList in ace completer
|
|
if (item.filterText) {
|
|
const firstWordMatch = item.filterText.match(/\w+/);
|
|
const firstWord = firstWordMatch ? firstWordMatch[0] : null;
|
|
if (firstWord) {
|
|
const wordRegex = new RegExp(`\\b${firstWord}\\b`, 'i');
|
|
if (!wordRegex.test(text)) {
|
|
text = `${item.filterText} ${text}`;
|
|
filterText = item.filterText;
|
|
}
|
|
} else {
|
|
if (!text.includes(item.filterText)) {
|
|
text = `${item.filterText} ${text}`;
|
|
filterText = item.filterText;
|
|
}
|
|
}
|
|
}
|
|
let command = ((_item_command = item.command) === null || _item_command === void 0 ? void 0 : _item_command.command) == "editor.action.triggerSuggest" ? "startAutocomplete" : undefined;
|
|
let range = item.textEdit ? getTextEditRange(item.textEdit, filterText) : undefined;
|
|
let completion = {
|
|
meta: kind,
|
|
caption: item.label,
|
|
score: undefined
|
|
};
|
|
completion["command"] = command;
|
|
completion["range"] = range;
|
|
completion["item"] = item;
|
|
if (item.insertTextFormat == InsertTextFormat.Snippet) {
|
|
completion["snippet"] = text;
|
|
} else {
|
|
completion["value"] = text !== null && text !== void 0 ? text : "";
|
|
}
|
|
completion["documentation"] = item.documentation; //TODO: this is workaround for services with instant completion
|
|
completion["position"] = item["position"];
|
|
completion["service"] = item["service"]; //TODO: since we have multiple servers, we need to determine which
|
|
// server to use for resolving
|
|
return completion;
|
|
}
|
|
function toCompletions(completions) {
|
|
if (completions.length > 0) {
|
|
let combinedCompletions = completions.map((el)=>{
|
|
if (!el.completions) {
|
|
return [];
|
|
}
|
|
let allCompletions;
|
|
if (Array.isArray(el.completions)) {
|
|
allCompletions = el.completions;
|
|
} else {
|
|
allCompletions = el.completions.items;
|
|
}
|
|
return allCompletions.map((item)=>{
|
|
item["service"] = el.service;
|
|
return item;
|
|
});
|
|
}).flat();
|
|
return combinedCompletions.map((item)=>toCompletion(item));
|
|
}
|
|
return [];
|
|
}
|
|
function toResolvedCompletion(completion, item) {
|
|
completion["docMarkdown"] = fromMarkupContent(item.documentation);
|
|
return completion;
|
|
}
|
|
function toCompletionItem(completion) {
|
|
let command;
|
|
if (completion["command"]) {
|
|
command = {
|
|
title: "triggerSuggest",
|
|
command: completion["command"]
|
|
};
|
|
}
|
|
var _completion_caption;
|
|
let completionItem = {
|
|
label: (_completion_caption = completion.caption) !== null && _completion_caption !== void 0 ? _completion_caption : "",
|
|
kind: CommonConverter.convertKind(completion.meta),
|
|
command: command,
|
|
insertTextFormat: completion["snippet"] ? InsertTextFormat.Snippet : InsertTextFormat.PlainText,
|
|
documentation: completion["documentation"]
|
|
};
|
|
if (completion["range"]) {
|
|
var _completion_snippet;
|
|
completionItem.textEdit = {
|
|
range: fromRange(completion["range"]),
|
|
newText: (_completion_snippet = completion["snippet"]) !== null && _completion_snippet !== void 0 ? _completion_snippet : completion["value"]
|
|
};
|
|
} else {
|
|
var _completion_snippet1;
|
|
completionItem.insertText = (_completion_snippet1 = completion["snippet"]) !== null && _completion_snippet1 !== void 0 ? _completion_snippet1 : completion["value"];
|
|
}
|
|
completionItem["fileName"] = completion["fileName"];
|
|
completionItem["position"] = completion["position"];
|
|
completionItem["item"] = completion["item"];
|
|
completionItem["service"] = completion["service"]; //TODO:
|
|
return completionItem;
|
|
}
|
|
function getTextEditRange(textEdit, filterText) {
|
|
const filterLength = filterText ? filterText.length : 0;
|
|
if ("insert" in textEdit && "replace" in textEdit) {
|
|
let mergedRanges = mergeRanges([
|
|
toRange(textEdit.insert),
|
|
toRange(textEdit.replace)
|
|
]);
|
|
return mergedRanges[0];
|
|
} else {
|
|
textEdit.range.start.character -= filterLength;
|
|
return toRange(textEdit.range);
|
|
}
|
|
}
|
|
function toTooltip(hover) {
|
|
var _hover_find;
|
|
if (!hover) return;
|
|
let content = hover.map((el)=>{
|
|
if (!el || !el.contents) return;
|
|
if (MarkupContent.is(el.contents)) {
|
|
return fromMarkupContent(el.contents);
|
|
} else if (MarkedString.is(el.contents)) {
|
|
if (typeof el.contents === "string") {
|
|
return el.contents;
|
|
}
|
|
return "```" + el.contents.value + "```";
|
|
} else {
|
|
let contents = el.contents.map((el)=>{
|
|
if (typeof el !== "string") {
|
|
return `\`\`\`${el.value}\`\`\``;
|
|
} else {
|
|
return el;
|
|
}
|
|
});
|
|
return contents.join("\n\n");
|
|
}
|
|
}).filter(notEmpty);
|
|
if (content.length === 0) return;
|
|
//TODO: it could be merged within all ranges in future
|
|
let lspRange = (_hover_find = hover.find((el)=>{
|
|
var _el;
|
|
return (_el = el) === null || _el === void 0 ? void 0 : _el.range;
|
|
})) === null || _hover_find === void 0 ? void 0 : _hover_find.range;
|
|
let range;
|
|
if (lspRange) range = toRange(lspRange);
|
|
return {
|
|
content: {
|
|
type: "markdown",
|
|
text: content.join("\n\n")
|
|
},
|
|
range: range
|
|
};
|
|
}
|
|
function fromSignatureHelp(signatureHelp) {
|
|
if (!signatureHelp) return;
|
|
let content = signatureHelp.map((el)=>{
|
|
var _el, _el1;
|
|
if (!el) return;
|
|
let signatureIndex = ((_el = el) === null || _el === void 0 ? void 0 : _el.activeSignature) || 0;
|
|
let activeSignature = el.signatures[signatureIndex];
|
|
if (!activeSignature) return;
|
|
let activeParam = (_el1 = el) === null || _el1 === void 0 ? void 0 : _el1.activeParameter;
|
|
let contents = activeSignature.label;
|
|
if (activeParam != undefined && activeSignature.parameters && activeSignature.parameters[activeParam]) {
|
|
let param = activeSignature.parameters[activeParam].label;
|
|
if (typeof param == "string") {
|
|
contents = contents.replace(param, `**${param}**`);
|
|
}
|
|
}
|
|
if (activeSignature.documentation) {
|
|
if (MarkupContent.is(activeSignature.documentation)) {
|
|
return contents + "\n\n" + fromMarkupContent(activeSignature.documentation);
|
|
} else {
|
|
contents += "\n\n" + activeSignature.documentation;
|
|
return contents;
|
|
}
|
|
} else {
|
|
return contents;
|
|
}
|
|
}).filter(notEmpty);
|
|
if (content.length === 0) return;
|
|
return {
|
|
content: {
|
|
type: "markdown",
|
|
text: content.join("\n\n")
|
|
}
|
|
};
|
|
}
|
|
function fromMarkupContent(content) {
|
|
if (!content) return;
|
|
if (typeof content === "string") {
|
|
return content;
|
|
} else {
|
|
return content.value;
|
|
}
|
|
}
|
|
function fromAceDelta(delta, eol) {
|
|
const text = delta.lines.length > 1 ? delta.lines.join(eol) : delta.lines[0];
|
|
return {
|
|
range: delta.action === "insert" ? rangeFromPositions(fromPoint(delta.start), fromPoint(delta.start)) : rangeFromPositions(fromPoint(delta.start), fromPoint(delta.end)),
|
|
text: delta.action === "insert" ? text : ""
|
|
};
|
|
}
|
|
function filterDiagnostics(diagnostics, filterErrors) {
|
|
return common_converters_CommonConverter.excludeByErrorMessage(diagnostics, filterErrors.errorMessagesToIgnore).map((el)=>{
|
|
if ((0,utils/* checkValueAgainstRegexpArray */.Tk)(el.message, filterErrors.errorMessagesToTreatAsWarning)) {
|
|
el.severity = main.DiagnosticSeverity.Warning;
|
|
} else if ((0,utils/* checkValueAgainstRegexpArray */.Tk)(el.message, filterErrors.errorMessagesToTreatAsInfo)) {
|
|
el.severity = main.DiagnosticSeverity.Information;
|
|
}
|
|
return el;
|
|
});
|
|
}
|
|
function fromDocumentHighlights(documentHighlights) {
|
|
return documentHighlights.map(function(el) {
|
|
let className = el.kind == 2 ? "language_highlight_read" : el.kind == 3 ? "language_highlight_write" : "language_highlight_text";
|
|
return toMarkerGroupItem(CommonConverter.toRange(toRange(el.range)), className);
|
|
});
|
|
}
|
|
function toMarkerGroupItem(range, className, tooltipText) {
|
|
let markerGroupItem = {
|
|
range: range,
|
|
className: className
|
|
};
|
|
if (tooltipText) {
|
|
markerGroupItem["tooltipText"] = tooltipText;
|
|
}
|
|
return markerGroupItem;
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./src/services/lua/lua-service.ts
|
|
function lua_service_define_property(obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
|
|
|
|
class LuaService extends base_service.BaseService {
|
|
async doValidation(document) {
|
|
let value = this.getDocumentValue(document.uri);
|
|
if (!value) return [];
|
|
let errors = [];
|
|
try {
|
|
this.$service.parse(value);
|
|
} catch (e) {
|
|
if (e instanceof this.$service.SyntaxError) {
|
|
errors.push({
|
|
range: {
|
|
start: {
|
|
line: e.line - 1,
|
|
character: e.column
|
|
},
|
|
end: {
|
|
line: e.line - 1,
|
|
character: e.column
|
|
}
|
|
},
|
|
message: e.message,
|
|
severity: 1
|
|
});
|
|
}
|
|
}
|
|
return filterDiagnostics(errors, this.optionsToFilterDiagnostics);
|
|
}
|
|
constructor(mode){
|
|
super(mode);
|
|
lua_service_define_property(this, "$service", void 0);
|
|
lua_service_define_property(this, "serviceCapabilities", {
|
|
diagnosticProvider: {
|
|
interFileDependencies: true,
|
|
workspaceDiagnostics: true
|
|
}
|
|
});
|
|
this.$service = luaparse;
|
|
}
|
|
}
|
|
|
|
})();
|
|
|
|
/******/ return __webpack_exports__;
|
|
/******/ })()
|
|
;
|
|
}); |