mirror of
https://github.com/neocities/neocities.git
synced 2025-04-25 09:42:36 +02:00
23373 lines
No EOL
633 KiB
JavaScript
23373 lines
No EOL
633 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);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 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;
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4849:
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
/*
|
|
php.js 0.1.0 <http://phpjs.hertzen.com/>
|
|
Copyright (c) 2013 Niklas von Hertzen
|
|
|
|
Released under MIT License
|
|
|
|
This file contains:
|
|
- [var PHP = {Constants:{}};]
|
|
- src/modules/tokenizer/constants.js
|
|
- src/parser/lexer.js
|
|
- src/parser/parser.js
|
|
- src/parser/yyn.js
|
|
- src/parser/yyn_stmt.js
|
|
- src/parser/yyn_expr.js
|
|
- src/parser/yyn_scalar.js
|
|
*/ var PHP = {
|
|
Constants: {}
|
|
};
|
|
PHP.Constants.T_THROW = 317;
|
|
PHP.Constants.T_INCLUDE = 272;
|
|
PHP.Constants.T_INCLUDE_ONCE = 273;
|
|
PHP.Constants.T_EVAL = 274;
|
|
PHP.Constants.T_REQUIRE = 275;
|
|
PHP.Constants.T_REQUIRE_ONCE = 276;
|
|
PHP.Constants.T_LOGICAL_OR = 277;
|
|
PHP.Constants.T_LOGICAL_XOR = 278;
|
|
PHP.Constants.T_LOGICAL_AND = 279;
|
|
PHP.Constants.T_PRINT = 280;
|
|
PHP.Constants.T_YIELD = 281;
|
|
PHP.Constants.T_DOUBLE_ARROW = 386;
|
|
PHP.Constants.T_YIELD_FROM = 282;
|
|
PHP.Constants.T_PLUS_EQUAL = 352;
|
|
PHP.Constants.T_MINUS_EQUAL = 353;
|
|
PHP.Constants.T_MUL_EQUAL = 354;
|
|
PHP.Constants.T_DIV_EQUAL = 355;
|
|
PHP.Constants.T_CONCAT_EQUAL = 356;
|
|
PHP.Constants.T_MOD_EQUAL = 357;
|
|
PHP.Constants.T_AND_EQUAL = 358;
|
|
PHP.Constants.T_OR_EQUAL = 359;
|
|
PHP.Constants.T_XOR_EQUAL = 360;
|
|
PHP.Constants.T_SL_EQUAL = 361;
|
|
PHP.Constants.T_SR_EQUAL = 362;
|
|
PHP.Constants.T_POW_EQUAL = 402;
|
|
PHP.Constants.T_COALESCE_EQUAL = 363;
|
|
PHP.Constants.T_COALESCE = 400;
|
|
PHP.Constants.T_BOOLEAN_OR = 364;
|
|
PHP.Constants.T_BOOLEAN_AND = 365;
|
|
PHP.Constants.T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG = 404;
|
|
PHP.Constants.T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG = 403;
|
|
PHP.Constants.T_IS_EQUAL = 366;
|
|
PHP.Constants.T_IS_NOT_EQUAL = 367;
|
|
PHP.Constants.T_IS_IDENTICAL = 368;
|
|
PHP.Constants.T_IS_NOT_IDENTICAL = 369;
|
|
PHP.Constants.T_SPACESHIP = 372;
|
|
PHP.Constants.T_IS_SMALLER_OR_EQUAL = 370;
|
|
PHP.Constants.T_IS_GREATER_OR_EQUAL = 371;
|
|
PHP.Constants.T_SL = 373;
|
|
PHP.Constants.T_SR = 374;
|
|
PHP.Constants.T_INSTANCEOF = 283;
|
|
PHP.Constants.T_INC = 375;
|
|
PHP.Constants.T_DEC = 376;
|
|
PHP.Constants.T_INT_CAST = 377;
|
|
PHP.Constants.T_DOUBLE_CAST = 378;
|
|
PHP.Constants.T_STRING_CAST = 379;
|
|
PHP.Constants.T_ARRAY_CAST = 380;
|
|
PHP.Constants.T_OBJECT_CAST = 381;
|
|
PHP.Constants.T_BOOL_CAST = 382;
|
|
PHP.Constants.T_UNSET_CAST = 383;
|
|
PHP.Constants.T_POW = 401;
|
|
PHP.Constants.T_NEW = 284;
|
|
PHP.Constants.T_CLONE = 285;
|
|
PHP.Constants.T_EXIT = 286;
|
|
PHP.Constants.T_IF = 287;
|
|
PHP.Constants.T_ELSEIF = 288;
|
|
PHP.Constants.T_ELSE = 289;
|
|
PHP.Constants.T_ENDIF = 290;
|
|
PHP.Constants.T_LNUMBER = 260;
|
|
PHP.Constants.T_DNUMBER = 261;
|
|
PHP.Constants.T_STRING = 262;
|
|
PHP.Constants.T_STRING_VARNAME = 270;
|
|
PHP.Constants.T_VARIABLE = 266;
|
|
PHP.Constants.T_NUM_STRING = 271;
|
|
PHP.Constants.T_INLINE_HTML = 267;
|
|
PHP.Constants.T_ENCAPSED_AND_WHITESPACE = 268;
|
|
PHP.Constants.T_CONSTANT_ENCAPSED_STRING = 269;
|
|
PHP.Constants.T_ECHO = 291;
|
|
PHP.Constants.T_DO = 292;
|
|
PHP.Constants.T_WHILE = 293;
|
|
PHP.Constants.T_ENDWHILE = 294;
|
|
PHP.Constants.T_FOR = 295;
|
|
PHP.Constants.T_ENDFOR = 296;
|
|
PHP.Constants.T_FOREACH = 297;
|
|
PHP.Constants.T_ENDFOREACH = 298;
|
|
PHP.Constants.T_DECLARE = 299;
|
|
PHP.Constants.T_ENDDECLARE = 300;
|
|
PHP.Constants.T_AS = 301;
|
|
PHP.Constants.T_SWITCH = 302;
|
|
PHP.Constants.T_MATCH = 306;
|
|
PHP.Constants.T_ENDSWITCH = 303;
|
|
PHP.Constants.T_CASE = 304;
|
|
PHP.Constants.T_DEFAULT = 305;
|
|
PHP.Constants.T_BREAK = 307;
|
|
PHP.Constants.T_CONTINUE = 308;
|
|
PHP.Constants.T_GOTO = 309;
|
|
PHP.Constants.T_FUNCTION = 310;
|
|
PHP.Constants.T_FN = 311;
|
|
PHP.Constants.T_CONST = 312;
|
|
PHP.Constants.T_RETURN = 313;
|
|
PHP.Constants.T_TRY = 314;
|
|
PHP.Constants.T_CATCH = 315;
|
|
PHP.Constants.T_FINALLY = 316;
|
|
PHP.Constants.T_THROW = 317;
|
|
PHP.Constants.T_USE = 318;
|
|
PHP.Constants.T_INSTEADOF = 319;
|
|
PHP.Constants.T_GLOBAL = 320;
|
|
PHP.Constants.T_STATIC = 321;
|
|
PHP.Constants.T_ABSTRACT = 322;
|
|
PHP.Constants.T_FINAL = 323;
|
|
PHP.Constants.T_PRIVATE = 324;
|
|
PHP.Constants.T_PROTECTED = 325;
|
|
PHP.Constants.T_PUBLIC = 326;
|
|
PHP.Constants.T_READONLY = 327;
|
|
PHP.Constants.T_VAR = 328;
|
|
PHP.Constants.T_UNSET = 329;
|
|
PHP.Constants.T_ISSET = 330;
|
|
PHP.Constants.T_EMPTY = 331;
|
|
PHP.Constants.T_HALT_COMPILER = 332;
|
|
PHP.Constants.T_CLASS = 333;
|
|
PHP.Constants.T_TRAIT = 334;
|
|
PHP.Constants.T_INTERFACE = 335;
|
|
PHP.Constants.T_ENUM = 336;
|
|
PHP.Constants.T_EXTENDS = 337;
|
|
PHP.Constants.T_IMPLEMENTS = 338;
|
|
PHP.Constants.T_OBJECT_OPERATOR = 384;
|
|
PHP.Constants.T_NULLSAFE_OBJECT_OPERATOR = 385;
|
|
PHP.Constants.T_DOUBLE_ARROW = 386;
|
|
PHP.Constants.T_LIST = 340;
|
|
PHP.Constants.T_ARRAY = 341;
|
|
PHP.Constants.T_CALLABLE = 342;
|
|
PHP.Constants.T_CLASS_C = 346;
|
|
PHP.Constants.T_TRAIT_C = 347;
|
|
PHP.Constants.T_METHOD_C = 348;
|
|
PHP.Constants.T_FUNC_C = 349;
|
|
PHP.Constants.T_LINE = 343;
|
|
PHP.Constants.T_FILE = 344;
|
|
PHP.Constants.T_START_HEREDOC = 393;
|
|
PHP.Constants.T_END_HEREDOC = 394;
|
|
PHP.Constants.T_DOLLAR_OPEN_CURLY_BRACES = 395;
|
|
PHP.Constants.T_CURLY_OPEN = 396;
|
|
PHP.Constants.T_PAAMAYIM_NEKUDOTAYIM = 397;
|
|
PHP.Constants.T_NAMESPACE = 339;
|
|
PHP.Constants.T_NS_C = 350;
|
|
PHP.Constants.T_DIR = 345;
|
|
PHP.Constants.T_NS_SEPARATOR = 398;
|
|
PHP.Constants.T_ELLIPSIS = 399;
|
|
PHP.Constants.T_NAME_FULLY_QUALIFIED = 263;
|
|
PHP.Constants.T_NAME_QUALIFIED = 265;
|
|
PHP.Constants.T_NAME_RELATIVE = 264;
|
|
PHP.Constants.T_ATTRIBUTE = 351;
|
|
PHP.Constants.T_ENUM = 336;
|
|
PHP.Constants.T_BAD_CHARACTER = 405;
|
|
PHP.Constants.T_COMMENT = 387;
|
|
PHP.Constants.T_DOC_COMMENT = 388;
|
|
PHP.Constants.T_OPEN_TAG = 389;
|
|
PHP.Constants.T_OPEN_TAG_WITH_ECHO = 390;
|
|
PHP.Constants.T_CLOSE_TAG = 391;
|
|
PHP.Constants.T_WHITESPACE = 392;
|
|
PHP.Lexer = function(src, ini) {
|
|
var heredoc, heredocEndAllowed, stateStack = [
|
|
'INITIAL'
|
|
], stackPos = 0, swapState = function(state) {
|
|
stateStack[stackPos] = state;
|
|
}, pushState = function(state) {
|
|
stateStack[++stackPos] = state;
|
|
}, popState = function() {
|
|
--stackPos;
|
|
}, shortOpenTag = ini === undefined || /^(on|true|1)$/i.test(ini.short_open_tag), openTag = shortOpenTag ? /^(\<\?php(?:\r\n|[ \t\r\n])|<\?|\<script language\=('|")?php('|")?\>)/i : /^(\<\?php(?:\r\n|[ \t\r\n])|\<script language\=('|")?php('|")?\>)/i, inlineHtml = shortOpenTag ? /[^<]*(?:<(?!\?|script language\=('|")?php('|")?\>)[^<]*)*/i : /[^<]*(?:<(?!\?=|\?php[ \t\r\n]|script language\=('|")?php('|")?\>)[^<]*)*/i, labelRegexPart = '[a-zA-Z_\\x7f-\\uffff][a-zA-Z0-9_\\x7f-\\uffff]*', stringRegexPart = function(quote) {
|
|
// Matches non-interpolated portion of interpolated string
|
|
return '[^' + quote + '\\\\${]*(?:(?:\\\\[\\s\\S]|\\$(?!\\{|[a-zA-Z_\\x7f-\\uffff])|\\{(?!\\$))[^' + quote + '\\\\${]*)*';
|
|
}, sharedStringTokens = [
|
|
{
|
|
value: PHP.Constants.T_VARIABLE,
|
|
re: new RegExp('^\\$' + labelRegexPart + '(?=\\[)'),
|
|
func: function() {
|
|
pushState('VAR_OFFSET');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_VARIABLE,
|
|
re: new RegExp('^\\$' + labelRegexPart + '(?=->' + labelRegexPart + ')'),
|
|
func: function() {
|
|
pushState('LOOKING_FOR_PROPERTY');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DOLLAR_OPEN_CURLY_BRACES,
|
|
re: new RegExp('^\\$\\{(?=' + labelRegexPart + '[\\[}])'),
|
|
func: function() {
|
|
pushState('LOOKING_FOR_VARNAME');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_VARIABLE,
|
|
re: new RegExp('^\\$' + labelRegexPart)
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DOLLAR_OPEN_CURLY_BRACES,
|
|
re: /^\$\{/,
|
|
func: function() {
|
|
pushState('IN_SCRIPTING');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CURLY_OPEN,
|
|
re: /^\{(?=\$)/,
|
|
func: function() {
|
|
pushState('IN_SCRIPTING');
|
|
}
|
|
}
|
|
], data = {
|
|
// Outside of PHP
|
|
'INITIAL': [
|
|
{
|
|
value: PHP.Constants.T_OPEN_TAG_WITH_ECHO,
|
|
re: /^<\?=/i,
|
|
func: function() {
|
|
swapState('IN_SCRIPTING');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_OPEN_TAG,
|
|
re: openTag,
|
|
func: function() {
|
|
swapState('IN_SCRIPTING');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_INLINE_HTML,
|
|
re: inlineHtml
|
|
}
|
|
],
|
|
'IN_SCRIPTING': [
|
|
// Match whitespace first
|
|
{
|
|
value: PHP.Constants.T_WHITESPACE,
|
|
re: /^[ \n\r\t]+/
|
|
},
|
|
// Keywords, sorted alphabetically
|
|
{
|
|
value: PHP.Constants.T_ABSTRACT,
|
|
re: /^abstract\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_LOGICAL_AND,
|
|
re: /^and\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ARRAY,
|
|
re: /^array\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_AS,
|
|
re: /^as\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_BREAK,
|
|
re: /^break\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CALLABLE,
|
|
re: /^callable\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CASE,
|
|
re: /^case\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CATCH,
|
|
re: /^catch\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CLASS,
|
|
re: /^class\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CLONE,
|
|
re: /^clone\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CONST,
|
|
re: /^const\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CONTINUE,
|
|
re: /^continue\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DECLARE,
|
|
re: /^declare\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DEFAULT,
|
|
re: /^default\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DO,
|
|
re: /^do\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ECHO,
|
|
re: /^echo\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ELSE,
|
|
re: /^else\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ELSEIF,
|
|
re: /^elseif\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENUM,
|
|
re: /^enum\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENDDECLARE,
|
|
re: /^enddeclare\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENDFOR,
|
|
re: /^endfor\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENDFOREACH,
|
|
re: /^endforeach\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENDIF,
|
|
re: /^endif\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENDSWITCH,
|
|
re: /^endswitch\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENDWHILE,
|
|
re: /^endwhile\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENUM,
|
|
re: /^enum\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_EMPTY,
|
|
re: /^empty\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_EVAL,
|
|
re: /^eval\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_EXIT,
|
|
re: /^(?:exit|die)\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_EXTENDS,
|
|
re: /^extends\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_FINAL,
|
|
re: /^final\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_FINALLY,
|
|
re: /^finally\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_FN,
|
|
re: /^fn\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_FOR,
|
|
re: /^for\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_FOREACH,
|
|
re: /^foreach\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_FUNCTION,
|
|
re: /^function\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_GLOBAL,
|
|
re: /^global\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_GOTO,
|
|
re: /^goto\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_IF,
|
|
re: /^if\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_IMPLEMENTS,
|
|
re: /^implements\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_INCLUDE,
|
|
re: /^include\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_INCLUDE_ONCE,
|
|
re: /^include_once\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_INSTANCEOF,
|
|
re: /^instanceof\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_INSTEADOF,
|
|
re: /^insteadof\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_INTERFACE,
|
|
re: /^interface\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ISSET,
|
|
re: /^isset\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_LIST,
|
|
re: /^list\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_MATCH,
|
|
re: /^match\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_NEW,
|
|
re: /^new\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_LOGICAL_OR,
|
|
re: /^or\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_PRINT,
|
|
re: /^print\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_PRIVATE,
|
|
re: /^private\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_PROTECTED,
|
|
re: /^protected\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_PUBLIC,
|
|
re: /^public\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_READONLY,
|
|
re: /^readonly\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_REQUIRE,
|
|
re: /^require\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_REQUIRE_ONCE,
|
|
re: /^require_once\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_STATIC,
|
|
re: /^static\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_SWITCH,
|
|
re: /^switch\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_THROW,
|
|
re: /^throw\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_TRAIT,
|
|
re: /^trait\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_TRY,
|
|
re: /^try\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_UNSET,
|
|
re: /^unset\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_USE,
|
|
re: /^use\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_VAR,
|
|
re: /^var\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_WHILE,
|
|
re: /^while\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_LOGICAL_XOR,
|
|
re: /^xor\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_YIELD_FROM,
|
|
re: /^yield\s+from\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_YIELD,
|
|
re: /^yield\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_RETURN,
|
|
re: /^return\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_METHOD_C,
|
|
re: /^__METHOD__\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_LINE,
|
|
re: /^__LINE__\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_FILE,
|
|
re: /^__FILE__\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_FUNC_C,
|
|
re: /^__FUNCTION__\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_NS_C,
|
|
re: /^__NAMESPACE__\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_TRAIT_C,
|
|
re: /^__TRAIT__\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DIR,
|
|
re: /^__DIR__\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CLASS_C,
|
|
re: /^__CLASS__\b/i
|
|
},
|
|
// Other tokens
|
|
{
|
|
value: PHP.Constants.T_AND_EQUAL,
|
|
re: /^&=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ARRAY_CAST,
|
|
re: /^\([ \t]*array[ \t]*\)/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_BOOL_CAST,
|
|
re: /^\([ \t]*(?:bool|boolean)[ \t]*\)/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DOUBLE_CAST,
|
|
re: /^\([ \t]*(?:real|float|double)[ \t]*\)/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_INT_CAST,
|
|
re: /^\([ \t]*(?:int|integer)[ \t]*\)/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_OBJECT_CAST,
|
|
re: /^\([ \t]*object[ \t]*\)/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_STRING_CAST,
|
|
re: /^\([ \t]*(?:binary|string)[ \t]*\)/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_UNSET_CAST,
|
|
re: /^\([ \t]*unset[ \t]*\)/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_BOOLEAN_AND,
|
|
re: /^&&/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG,
|
|
re: /^&(?=[$])/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG,
|
|
re: /^(&)(?=[^\$|^&])/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_BOOLEAN_OR,
|
|
re: /^\|\|/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CLOSE_TAG,
|
|
re: /^(?:\?>|<\/script>)(\r\n|\r|\n)?/i,
|
|
func: function() {
|
|
swapState('INITIAL');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DOUBLE_ARROW,
|
|
re: /^=>/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_PAAMAYIM_NEKUDOTAYIM,
|
|
re: /^::/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_INC,
|
|
re: /^\+\+/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DEC,
|
|
re: /^--/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CONCAT_EQUAL,
|
|
re: /^\.=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DIV_EQUAL,
|
|
re: /^\/=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_XOR_EQUAL,
|
|
re: /^\^=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_MUL_EQUAL,
|
|
re: /^\*=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_MOD_EQUAL,
|
|
re: /^%=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_SL_EQUAL,
|
|
re: /^<<=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_START_HEREDOC,
|
|
re: new RegExp('^[bB]?<<<[ \\t]*\'(' + labelRegexPart + ')\'(?:\\r\\n|\\r|\\n)'),
|
|
func: function(result) {
|
|
heredoc = result[1];
|
|
swapState('NOWDOC');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_START_HEREDOC,
|
|
re: new RegExp('^[bB]?<<<[ \\t]*("?)(' + labelRegexPart + ')\\1(?:\\r\\n|\\r|\\n)'),
|
|
func: function(result) {
|
|
heredoc = result[2];
|
|
heredocEndAllowed = true;
|
|
swapState('HEREDOC');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_SL,
|
|
re: /^<</
|
|
},
|
|
{
|
|
value: PHP.Constants.T_SPACESHIP,
|
|
re: /^<=>/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_IS_SMALLER_OR_EQUAL,
|
|
re: /^<=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_SR_EQUAL,
|
|
re: /^>>=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_SR,
|
|
re: /^>>/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_IS_GREATER_OR_EQUAL,
|
|
re: /^>=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_OR_EQUAL,
|
|
re: /^\|=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_PLUS_EQUAL,
|
|
re: /^\+=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_MINUS_EQUAL,
|
|
re: /^-=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_OBJECT_OPERATOR,
|
|
re: new RegExp('^->(?=[ \n\r\t]*' + labelRegexPart + ')'),
|
|
func: function() {
|
|
pushState('LOOKING_FOR_PROPERTY');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_OBJECT_OPERATOR,
|
|
re: /^->/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ELLIPSIS,
|
|
re: /^\.\.\./
|
|
},
|
|
{
|
|
value: PHP.Constants.T_POW_EQUAL,
|
|
re: /^\*\*=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_POW,
|
|
re: /^\*\*/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_COALESCE_EQUAL,
|
|
re: /^\?\?=/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_COALESCE,
|
|
re: /^\?\?/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_NULLSAFE_OBJECT_OPERATOR,
|
|
re: /^\?->/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_NAME_FULLY_QUALIFIED,
|
|
re: /^\\\w+(?:\\\w+)*/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_NAME_QUALIFIED,
|
|
re: /^\w+\\\w+(?:\\\w+)*/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_NAME_RELATIVE,
|
|
re: /^namespace\\\w+(?:\\\w+)*/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_NAMESPACE,
|
|
re: /^namespace\b/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ATTRIBUTE,
|
|
re: /^#\[([\S\s]*?)]/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_COMMENT,
|
|
re: /^\/\*([\S\s]*?)(?:\*\/|$)/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_COMMENT,
|
|
re: /^(?:\/\/|#)[^\r\n?]*(?:\?(?!>)[^\r\n?]*)*(?:\r\n|\r|\n)?/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_IS_IDENTICAL,
|
|
re: /^===/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_IS_EQUAL,
|
|
re: /^==/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_IS_NOT_IDENTICAL,
|
|
re: /^!==/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_IS_NOT_EQUAL,
|
|
re: /^(!=|<>)/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DNUMBER,
|
|
re: /^(?:[0-9]+\.[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_DNUMBER,
|
|
re: /^[0-9]+[eE][+-]?[0-9]+/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_LNUMBER,
|
|
re: /^(?:0x[0-9A-F]+|0b[01]+|[0-9]+)/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_VARIABLE,
|
|
re: new RegExp('^\\$' + labelRegexPart)
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CONSTANT_ENCAPSED_STRING,
|
|
re: /^[bB]?'[^'\\]*(?:\\[\s\S][^'\\]*)*'/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_CONSTANT_ENCAPSED_STRING,
|
|
re: new RegExp('^[bB]?"' + stringRegexPart('"') + '"')
|
|
},
|
|
{
|
|
value: -1,
|
|
re: /^[bB]?"/,
|
|
func: function() {
|
|
swapState('DOUBLE_QUOTES');
|
|
}
|
|
},
|
|
{
|
|
value: -1,
|
|
re: /^`/,
|
|
func: function() {
|
|
swapState('BACKTICKS');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_NS_SEPARATOR,
|
|
re: /^\\/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_STRING,
|
|
re: /^[a-zA-Z_\x7f-\uffff][a-zA-Z0-9_\x7f-\uffff]*/
|
|
},
|
|
{
|
|
value: -1,
|
|
re: /^\{/,
|
|
func: function() {
|
|
pushState('IN_SCRIPTING');
|
|
}
|
|
},
|
|
{
|
|
value: -1,
|
|
re: /^\}/,
|
|
func: function() {
|
|
if (stackPos > 0) {
|
|
popState();
|
|
}
|
|
}
|
|
},
|
|
{
|
|
value: -1,
|
|
re: /^[\[\];:?()!.,><=+-/*|&@^%"'$~]/
|
|
}
|
|
],
|
|
'DOUBLE_QUOTES': sharedStringTokens.concat([
|
|
{
|
|
value: -1,
|
|
re: /^"/,
|
|
func: function() {
|
|
swapState('IN_SCRIPTING');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENCAPSED_AND_WHITESPACE,
|
|
re: new RegExp('^' + stringRegexPart('"'))
|
|
}
|
|
]),
|
|
'BACKTICKS': sharedStringTokens.concat([
|
|
{
|
|
value: -1,
|
|
re: /^`/,
|
|
func: function() {
|
|
swapState('IN_SCRIPTING');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENCAPSED_AND_WHITESPACE,
|
|
re: new RegExp('^' + stringRegexPart('`'))
|
|
}
|
|
]),
|
|
'VAR_OFFSET': [
|
|
{
|
|
value: -1,
|
|
re: /^\]/,
|
|
func: function() {
|
|
popState();
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_NUM_STRING,
|
|
re: /^(?:0x[0-9A-F]+|0b[01]+|[0-9]+)/i
|
|
},
|
|
{
|
|
value: PHP.Constants.T_VARIABLE,
|
|
re: new RegExp('^\\$' + labelRegexPart)
|
|
},
|
|
{
|
|
value: PHP.Constants.T_STRING,
|
|
re: new RegExp('^' + labelRegexPart)
|
|
},
|
|
{
|
|
value: -1,
|
|
re: /^[;:,.\[()|^&+-/*=%!~$<>?@{}"`]/
|
|
}
|
|
],
|
|
'LOOKING_FOR_PROPERTY': [
|
|
{
|
|
value: PHP.Constants.T_OBJECT_OPERATOR,
|
|
re: /^->/
|
|
},
|
|
{
|
|
value: PHP.Constants.T_STRING,
|
|
re: new RegExp('^' + labelRegexPart),
|
|
func: function() {
|
|
popState();
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_WHITESPACE,
|
|
re: /^[ \n\r\t]+/
|
|
}
|
|
],
|
|
'LOOKING_FOR_VARNAME': [
|
|
{
|
|
value: PHP.Constants.T_STRING_VARNAME,
|
|
re: new RegExp('^' + labelRegexPart + '(?=[\\[}])'),
|
|
func: function() {
|
|
swapState('IN_SCRIPTING');
|
|
}
|
|
}
|
|
],
|
|
'NOWDOC': [
|
|
{
|
|
value: PHP.Constants.T_END_HEREDOC,
|
|
matchFunc: function(src) {
|
|
var re = new RegExp('^' + heredoc + '(?=;?[\\r\\n])');
|
|
if (src.match(re)) {
|
|
return [
|
|
src.substr(0, heredoc.length)
|
|
];
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
func: function() {
|
|
swapState('IN_SCRIPTING');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENCAPSED_AND_WHITESPACE,
|
|
matchFunc: function(src) {
|
|
var re = new RegExp('[\\r\\n]' + heredoc + '(?=;?[\\r\\n])');
|
|
var result = re.exec(src);
|
|
var end = result ? result.index + 1 : src.length;
|
|
return [
|
|
src.substring(0, end)
|
|
];
|
|
}
|
|
}
|
|
],
|
|
'HEREDOC': sharedStringTokens.concat([
|
|
{
|
|
value: PHP.Constants.T_END_HEREDOC,
|
|
matchFunc: function(src) {
|
|
if (!heredocEndAllowed) {
|
|
return null;
|
|
}
|
|
var re = new RegExp('^' + heredoc + '(?=;?[\\r\\n])');
|
|
if (src.match(re)) {
|
|
return [
|
|
src.substr(0, heredoc.length)
|
|
];
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
func: function() {
|
|
swapState('IN_SCRIPTING');
|
|
}
|
|
},
|
|
{
|
|
value: PHP.Constants.T_ENCAPSED_AND_WHITESPACE,
|
|
matchFunc: function(src) {
|
|
var end = src.length;
|
|
// Find next interpolation
|
|
var re = new RegExp('^' + stringRegexPart(''));
|
|
var result = re.exec(src);
|
|
if (result) {
|
|
end = result[0].length;
|
|
}
|
|
// Find heredoc end
|
|
re = new RegExp('([\\r\\n])' + heredoc + '(?=;?[\\r\\n])');
|
|
result = re.exec(src.substring(0, end));
|
|
if (result) {
|
|
end = result.index + 1;
|
|
heredocEndAllowed = true;
|
|
} else {
|
|
heredocEndAllowed = false;
|
|
}
|
|
if (end == 0) {
|
|
return null;
|
|
}
|
|
return [
|
|
src.substring(0, end)
|
|
];
|
|
}
|
|
}
|
|
])
|
|
};
|
|
var results = [], line = 1, cancel = true;
|
|
if (src === null) {
|
|
return results;
|
|
}
|
|
if (typeof src !== "string") {
|
|
src = src.toString();
|
|
}
|
|
while(src.length > 0 && cancel === true){
|
|
var state = stateStack[stackPos];
|
|
var tokens = data[state];
|
|
cancel = tokens.some(function(token) {
|
|
var result = token.matchFunc !== undefined ? token.matchFunc(src) : src.match(token.re);
|
|
if (result !== null) {
|
|
if (result[0].length == 0) {
|
|
// Error in the lexer definition, prevent infinite loop
|
|
throw new Error("empty match");
|
|
}
|
|
if (token.func !== undefined) {
|
|
token.func(result);
|
|
}
|
|
if (token.value === -1) {
|
|
// character token
|
|
results.push(result[0]);
|
|
} else {
|
|
var resultString = result[0];
|
|
results.push([
|
|
parseInt(token.value, 10),
|
|
resultString,
|
|
line
|
|
]);
|
|
line += resultString.split('\n').length - 1;
|
|
}
|
|
src = src.substring(result[0].length);
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
return results;
|
|
};
|
|
/*
|
|
* @author Niklas von Hertzen <niklas at hertzen.com>
|
|
* @created 15.6.2012
|
|
* @website http://hertzen.com
|
|
*/ /*
|
|
* The skeleton for this parser was written by Moriyoshi Koizumi and is based on
|
|
* the work by Masato Bito and is in the PUBLIC DOMAIN.
|
|
* Ported to JavaScript by Niklas von Hertzen
|
|
*/ PHP.Parser = function(preprocessedTokens, evaluate) {
|
|
var yybase = this.yybase, yydefault = this.yydefault, yycheck = this.yycheck, yyaction = this.yyaction, yylen = this.yylen, yygbase = this.yygbase, yygcheck = this.yygcheck, yyp = this.yyp, yygoto = this.yygoto, yylhs = this.yylhs, terminals = this.terminals, translate = this.translate, yygdefault = this.yygdefault;
|
|
this.pos = -1;
|
|
this.line = 1;
|
|
this.tokenMap = this.createTokenMap();
|
|
this.dropTokens = {};
|
|
this.dropTokens[PHP.Constants.T_WHITESPACE] = 1;
|
|
this.dropTokens[PHP.Constants.T_OPEN_TAG] = 1;
|
|
var tokens = [];
|
|
// pre-process
|
|
preprocessedTokens.forEach(function(token, index) {
|
|
if (typeof token === "object" && token[0] === PHP.Constants.T_OPEN_TAG_WITH_ECHO) {
|
|
tokens.push([
|
|
PHP.Constants.T_OPEN_TAG,
|
|
token[1],
|
|
token[2]
|
|
]);
|
|
tokens.push([
|
|
PHP.Constants.T_ECHO,
|
|
token[1],
|
|
token[2]
|
|
]);
|
|
} else {
|
|
tokens.push(token);
|
|
}
|
|
});
|
|
this.tokens = tokens;
|
|
// We start off with no lookahead-token
|
|
var tokenId = this.TOKEN_NONE;
|
|
// The attributes for a node are taken from the first and last token of the node.
|
|
// From the first token only the startAttributes are taken and from the last only
|
|
// the endAttributes. Both are merged using the array union operator (+).
|
|
this.startAttributes = {
|
|
'startLine': 1
|
|
};
|
|
this.endAttributes = {};
|
|
// In order to figure out the attributes for the starting token, we have to keep
|
|
// them in a stack
|
|
var attributeStack = [
|
|
this.startAttributes
|
|
];
|
|
// Start off in the initial state and keep a stack of previous states
|
|
var state = 0;
|
|
var stateStack = [
|
|
state
|
|
];
|
|
// AST stack
|
|
this.yyastk = [];
|
|
// Current position in the stack(s)
|
|
this.stackPos = 0;
|
|
var yyn;
|
|
var origTokenId;
|
|
for(;;){
|
|
if (yybase[state] === 0) {
|
|
yyn = yydefault[state];
|
|
} else {
|
|
if (tokenId === this.TOKEN_NONE) {
|
|
// fetch the next token id from the lexer and fetch additional info by-ref
|
|
origTokenId = this.getNextToken();
|
|
// map the lexer token id to the internally used token id's
|
|
tokenId = origTokenId >= 0 && origTokenId < this.TOKEN_MAP_SIZE ? translate[origTokenId] : this.TOKEN_INVALID;
|
|
attributeStack[this.stackPos] = this.startAttributes;
|
|
}
|
|
if (((yyn = yybase[state] + tokenId) >= 0 && yyn < this.YYLAST && yycheck[yyn] === tokenId || state < this.YY2TBLSTATE && (yyn = yybase[state + this.YYNLSTATES] + tokenId) >= 0 && yyn < this.YYLAST && yycheck[yyn] === tokenId) && (yyn = yyaction[yyn]) !== this.YYDEFAULT) {
|
|
/*
|
|
* >= YYNLSTATE: shift and reduce
|
|
* > 0: shift
|
|
* = 0: accept
|
|
* < 0: reduce
|
|
* = -YYUNEXPECTED: error
|
|
*/ if (yyn > 0) {
|
|
/* shift */ ++this.stackPos;
|
|
stateStack[this.stackPos] = state = yyn;
|
|
this.yyastk[this.stackPos] = this.tokenValue;
|
|
attributeStack[this.stackPos] = this.startAttributes;
|
|
tokenId = this.TOKEN_NONE;
|
|
if (yyn < this.YYNLSTATES) continue;
|
|
/* $yyn >= YYNLSTATES means shift-and-reduce */ yyn -= this.YYNLSTATES;
|
|
} else {
|
|
yyn = -yyn;
|
|
}
|
|
} else {
|
|
yyn = yydefault[state];
|
|
}
|
|
}
|
|
for(;;){
|
|
/* reduce/error */ if (yyn === 0) {
|
|
/* accept */ return this.yyval;
|
|
} else if (yyn !== this.YYUNEXPECTED) {
|
|
/* reduce */ for(var attr in this.endAttributes){
|
|
attributeStack[this.stackPos - yylen[yyn]][attr] = this.endAttributes[attr];
|
|
}
|
|
// We do not build an AST!
|
|
// this['yyn' + yyn](attributeStack[ this.stackPos - yylen[ yyn ] ]);
|
|
/* Goto - shift nonterminal */ this.stackPos -= yylen[yyn];
|
|
yyn = yylhs[yyn];
|
|
if ((yyp = yygbase[yyn] + stateStack[this.stackPos]) >= 0 && yyp < this.YYGLAST && yygcheck[yyp] === yyn) {
|
|
state = yygoto[yyp];
|
|
} else {
|
|
state = yygdefault[yyn];
|
|
}
|
|
++this.stackPos;
|
|
stateStack[this.stackPos] = state;
|
|
this.yyastk[this.stackPos] = this.yyval;
|
|
attributeStack[this.stackPos] = this.startAttributes;
|
|
} else {
|
|
/* error */ if (evaluate !== true) {
|
|
var expected = [];
|
|
for(var i = 0; i < this.TOKEN_MAP_SIZE; ++i){
|
|
if ((yyn = yybase[state] + i) >= 0 && yyn < this.YYLAST && yycheck[yyn] == i || state < this.YY2TBLSTATE && (yyn = yybase[state + this.YYNLSTATES] + i) && yyn < this.YYLAST && yycheck[yyn] == i) {
|
|
if (yyaction[yyn] != this.YYUNEXPECTED) {
|
|
if (expected.length == 4) {
|
|
/* Too many expected tokens */ expected = [];
|
|
break;
|
|
}
|
|
expected.push(this.terminals[i]);
|
|
}
|
|
}
|
|
}
|
|
var expectedString = '';
|
|
if (expected.length) {
|
|
expectedString = ', expecting ' + expected.join(' or ');
|
|
}
|
|
throw new PHP.ParseError('syntax error, unexpected ' + terminals[tokenId] + expectedString, this.startAttributes['startLine']);
|
|
} else {
|
|
return this.startAttributes['startLine'];
|
|
}
|
|
}
|
|
if (state < this.YYNLSTATES) break;
|
|
/* >= YYNLSTATES means shift-and-reduce */ yyn = state - this.YYNLSTATES;
|
|
}
|
|
}
|
|
};
|
|
PHP.ParseError = function(msg, line) {
|
|
this.message = msg;
|
|
this.line = line;
|
|
};
|
|
PHP.Parser.prototype.getNextToken = function() {
|
|
this.startAttributes = {};
|
|
this.endAttributes = {};
|
|
var token, tmp;
|
|
while(this.tokens[++this.pos] !== undefined){
|
|
token = this.tokens[this.pos];
|
|
if (typeof token === "string") {
|
|
this.startAttributes['startLine'] = this.line;
|
|
this.endAttributes['endLine'] = this.line;
|
|
// bug in token_get_all
|
|
if ('b"' === token) {
|
|
this.tokenValue = 'b"';
|
|
return '"'.charCodeAt(0);
|
|
} else {
|
|
this.tokenValue = token;
|
|
return token.charCodeAt(0);
|
|
}
|
|
} else {
|
|
this.line += (tmp = token[1].match(/\n/g)) === null ? 0 : tmp.length;
|
|
if (PHP.Constants.T_COMMENT === token[0]) {
|
|
if (!Array.isArray(this.startAttributes['comments'])) {
|
|
this.startAttributes['comments'] = [];
|
|
}
|
|
this.startAttributes['comments'].push({
|
|
type: "comment",
|
|
comment: token[1],
|
|
line: token[2]
|
|
});
|
|
} else if (PHP.Constants.T_ATTRIBUTE === token[0]) {
|
|
this.tokenValue = token[1];
|
|
this.startAttributes['startLine'] = token[2];
|
|
this.endAttributes['endLine'] = this.line;
|
|
} else if (PHP.Constants.T_DOC_COMMENT === token[0]) {
|
|
this.startAttributes['comments'].push(new PHPParser_Comment_Doc(token[1], token[2]));
|
|
} else if (this.dropTokens[token[0]] === undefined) {
|
|
this.tokenValue = token[1];
|
|
this.startAttributes['startLine'] = token[2];
|
|
this.endAttributes['endLine'] = this.line;
|
|
return this.tokenMap[token[0]];
|
|
}
|
|
}
|
|
}
|
|
this.startAttributes['startLine'] = this.line;
|
|
// 0 is the EOF token
|
|
return 0;
|
|
};
|
|
PHP.Parser.prototype.tokenName = function(token) {
|
|
var constants = [
|
|
"T_THROW",
|
|
"T_INCLUDE",
|
|
"T_INCLUDE_ONCE",
|
|
"T_EVAL",
|
|
"T_REQUIRE",
|
|
"T_REQUIRE_ONCE",
|
|
"T_LOGICAL_OR",
|
|
"T_LOGICAL_XOR",
|
|
"T_LOGICAL_AND",
|
|
"T_PRINT",
|
|
"T_YIELD",
|
|
"T_DOUBLE_ARROW",
|
|
"T_YIELD_FROM",
|
|
"T_PLUS_EQUAL",
|
|
"T_MINUS_EQUAL",
|
|
"T_MUL_EQUAL",
|
|
"T_DIV_EQUAL",
|
|
"T_CONCAT_EQUAL",
|
|
"T_MOD_EQUAL",
|
|
"T_AND_EQUAL",
|
|
"T_OR_EQUAL",
|
|
"T_XOR_EQUAL",
|
|
"T_SL_EQUAL",
|
|
"T_SR_EQUAL",
|
|
"T_POW_EQUAL",
|
|
"T_COALESCE_EQUAL",
|
|
"T_COALESCE",
|
|
"T_BOOLEAN_OR",
|
|
"T_BOOLEAN_AND",
|
|
"T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG",
|
|
"T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG",
|
|
"T_IS_EQUAL",
|
|
"T_IS_NOT_EQUAL",
|
|
"T_IS_IDENTICAL",
|
|
"T_IS_NOT_IDENTICAL",
|
|
"T_SPACESHIP",
|
|
"T_IS_SMALLER_OR_EQUAL",
|
|
"T_IS_GREATER_OR_EQUAL",
|
|
"T_SL",
|
|
"T_SR",
|
|
"T_INSTANCEOF",
|
|
"T_INC",
|
|
"T_DEC",
|
|
"T_INT_CAST",
|
|
"T_DOUBLE_CAST",
|
|
"T_STRING_CAST",
|
|
"T_ARRAY_CAST",
|
|
"T_OBJECT_CAST",
|
|
"T_BOOL_CAST",
|
|
"T_UNSET_CAST",
|
|
"T_POW",
|
|
"T_NEW",
|
|
"T_CLONE",
|
|
"T_EXIT",
|
|
"T_IF",
|
|
"T_ELSEIF",
|
|
"T_ELSE",
|
|
"T_ENDIF",
|
|
"T_LNUMBER",
|
|
"T_DNUMBER",
|
|
"T_STRING",
|
|
"T_STRING_VARNAME",
|
|
"T_VARIABLE",
|
|
"T_NUM_STRING",
|
|
"T_INLINE_HTML",
|
|
"T_ENCAPSED_AND_WHITESPACE",
|
|
"T_CONSTANT_ENCAPSED_STRING",
|
|
"T_ECHO",
|
|
"T_DO",
|
|
"T_WHILE",
|
|
"T_ENDWHILE",
|
|
"T_FOR",
|
|
"T_ENDFOR",
|
|
"T_FOREACH",
|
|
"T_ENDFOREACH",
|
|
"T_DECLARE",
|
|
"T_ENDDECLARE",
|
|
"T_AS",
|
|
"T_SWITCH",
|
|
"T_MATCH",
|
|
"T_ENDSWITCH",
|
|
"T_CASE",
|
|
"T_DEFAULT",
|
|
"T_BREAK",
|
|
"T_CONTINUE",
|
|
"T_GOTO",
|
|
"T_FUNCTION",
|
|
"T_FN",
|
|
"T_CONST",
|
|
"T_RETURN",
|
|
"T_TRY",
|
|
"T_CATCH",
|
|
"T_FINALLY",
|
|
"T_THROW",
|
|
"T_USE",
|
|
"T_INSTEADOF",
|
|
"T_GLOBAL",
|
|
"T_STATIC",
|
|
"T_ABSTRACT",
|
|
"T_FINAL",
|
|
"T_PRIVATE",
|
|
"T_PROTECTED",
|
|
"T_PUBLIC",
|
|
"T_READONLY",
|
|
"T_VAR",
|
|
"T_UNSET",
|
|
"T_ISSET",
|
|
"T_EMPTY",
|
|
"T_HALT_COMPILER",
|
|
"T_CLASS",
|
|
"T_TRAIT",
|
|
"T_INTERFACE",
|
|
"T_ENUM",
|
|
"T_EXTENDS",
|
|
"T_IMPLEMENTS",
|
|
"T_OBJECT_OPERATOR",
|
|
"T_NULLSAFE_OBJECT_OPERATOR",
|
|
"T_DOUBLE_ARROW",
|
|
"T_LIST",
|
|
"T_ARRAY",
|
|
"T_CALLABLE",
|
|
"T_CLASS_C",
|
|
"T_TRAIT_C",
|
|
"T_METHOD_C",
|
|
"T_FUNC_C",
|
|
"T_LINE",
|
|
"T_FILE",
|
|
"T_START_HEREDOC",
|
|
"T_END_HEREDOC",
|
|
"T_DOLLAR_OPEN_CURLY_BRACES",
|
|
"T_CURLY_OPEN",
|
|
"T_PAAMAYIM_NEKUDOTAYIM",
|
|
"T_NAMESPACE",
|
|
"T_NS_C",
|
|
"T_DIR",
|
|
"T_NS_SEPARATOR",
|
|
"T_ELLIPSIS",
|
|
"T_NAME_FULLY_QUALIFIED",
|
|
"T_NAME_QUALIFIED",
|
|
"T_NAME_RELATIVE",
|
|
"T_ATTRIBUTE",
|
|
"T_ENUM",
|
|
"T_BAD_CHARACTER",
|
|
"T_COMMENT",
|
|
"T_DOC_COMMENT",
|
|
"T_OPEN_TAG",
|
|
"T_OPEN_TAG_WITH_ECHO",
|
|
"T_CLOSE_TAG",
|
|
"T_WHITESPACE"
|
|
];
|
|
var current = "UNKNOWN";
|
|
constants.some(function(constant) {
|
|
if (PHP.Constants[constant] === token) {
|
|
current = constant;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
});
|
|
return current;
|
|
};
|
|
/**
|
|
* Creates the token map.
|
|
*
|
|
* The token map maps the PHP internal token identifiers
|
|
* to the identifiers used by the PHP.Parser. Additionally it
|
|
* maps T_OPEN_TAG_WITH_ECHO to T_ECHO and T_CLOSE_TAG to ';'.
|
|
*
|
|
* @return array The token map
|
|
*/ PHP.Parser.prototype.createTokenMap = function() {
|
|
var tokenMap = {}, name, i;
|
|
// 256 is the minimum possible token number, as everything below
|
|
// it is an ASCII value
|
|
for(i = 256; i < 1000; ++i){
|
|
// T_OPEN_TAG_WITH_ECHO with dropped T_OPEN_TAG results in T_ECHO
|
|
if (PHP.Constants.T_OPEN_TAG_WITH_ECHO === i) {
|
|
tokenMap[i] = PHP.Constants.T_ECHO;
|
|
// T_CLOSE_TAG is equivalent to ';'
|
|
} else if (PHP.Constants.T_CLOSE_TAG === i) {
|
|
tokenMap[i] = 59;
|
|
// and the others can be mapped directly
|
|
} else if ('UNKNOWN' !== (name = this.tokenName(i))) {
|
|
tokenMap[i] = this[name];
|
|
}
|
|
}
|
|
return tokenMap;
|
|
};
|
|
/* This is an automatically GENERATED file, which should not be manually edited.
|
|
* Instead edit one of the following:
|
|
* * the grammar file grammar/zend_language_parser.jsy
|
|
* * the parser skeleton grammar/kymacc.js.parser
|
|
* * the preprocessing script grammar/rebuildParser.php
|
|
*
|
|
* The skeleton for this parser was written by Moriyoshi Koizumi and is based on
|
|
* the work by Masato Bito and is in the PUBLIC DOMAIN.
|
|
* Ported to JavaScript by Niklas von Hertzen
|
|
*/ PHP.Parser.prototype.TOKEN_NONE = -1;
|
|
PHP.Parser.prototype.TOKEN_INVALID = 175;
|
|
PHP.Parser.prototype.TOKEN_MAP_SIZE = 403;
|
|
PHP.Parser.prototype.YYLAST = 1196;
|
|
PHP.Parser.prototype.YY2TBLSTATE = 420;
|
|
PHP.Parser.prototype.YYGLAST = 545;
|
|
PHP.Parser.prototype.YYNLSTATES = 710;
|
|
PHP.Parser.prototype.YYUNEXPECTED = 32767;
|
|
PHP.Parser.prototype.YYDEFAULT = -32766;
|
|
// {{{ Tokens
|
|
PHP.Parser.prototype.YYERRTOK = 256;
|
|
PHP.Parser.prototype.T_THROW = 257;
|
|
PHP.Parser.prototype.T_INCLUDE = 258;
|
|
PHP.Parser.prototype.T_INCLUDE_ONCE = 259;
|
|
PHP.Parser.prototype.T_EVAL = 260;
|
|
PHP.Parser.prototype.T_REQUIRE = 261;
|
|
PHP.Parser.prototype.T_REQUIRE_ONCE = 262;
|
|
PHP.Parser.prototype.T_LOGICAL_OR = 263;
|
|
PHP.Parser.prototype.T_LOGICAL_XOR = 264;
|
|
PHP.Parser.prototype.T_LOGICAL_AND = 265;
|
|
PHP.Parser.prototype.T_PRINT = 266;
|
|
PHP.Parser.prototype.T_YIELD = 267;
|
|
PHP.Parser.prototype.T_DOUBLE_ARROW = 268;
|
|
PHP.Parser.prototype.T_YIELD_FROM = 269;
|
|
PHP.Parser.prototype.T_PLUS_EQUAL = 270;
|
|
PHP.Parser.prototype.T_MINUS_EQUAL = 271;
|
|
PHP.Parser.prototype.T_MUL_EQUAL = 272;
|
|
PHP.Parser.prototype.T_DIV_EQUAL = 273;
|
|
PHP.Parser.prototype.T_CONCAT_EQUAL = 274;
|
|
PHP.Parser.prototype.T_MOD_EQUAL = 275;
|
|
PHP.Parser.prototype.T_AND_EQUAL = 276;
|
|
PHP.Parser.prototype.T_OR_EQUAL = 277;
|
|
PHP.Parser.prototype.T_XOR_EQUAL = 278;
|
|
PHP.Parser.prototype.T_SL_EQUAL = 279;
|
|
PHP.Parser.prototype.T_SR_EQUAL = 280;
|
|
PHP.Parser.prototype.T_POW_EQUAL = 281;
|
|
PHP.Parser.prototype.T_COALESCE_EQUAL = 282;
|
|
PHP.Parser.prototype.T_COALESCE = 283;
|
|
PHP.Parser.prototype.T_BOOLEAN_OR = 284;
|
|
PHP.Parser.prototype.T_BOOLEAN_AND = 285;
|
|
PHP.Parser.prototype.T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG = 286;
|
|
PHP.Parser.prototype.T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG = 287;
|
|
PHP.Parser.prototype.T_IS_EQUAL = 288;
|
|
PHP.Parser.prototype.T_IS_NOT_EQUAL = 289;
|
|
PHP.Parser.prototype.T_IS_IDENTICAL = 290;
|
|
PHP.Parser.prototype.T_IS_NOT_IDENTICAL = 291;
|
|
PHP.Parser.prototype.T_SPACESHIP = 292;
|
|
PHP.Parser.prototype.T_IS_SMALLER_OR_EQUAL = 293;
|
|
PHP.Parser.prototype.T_IS_GREATER_OR_EQUAL = 294;
|
|
PHP.Parser.prototype.T_SL = 295;
|
|
PHP.Parser.prototype.T_SR = 296;
|
|
PHP.Parser.prototype.T_INSTANCEOF = 297;
|
|
PHP.Parser.prototype.T_INC = 298;
|
|
PHP.Parser.prototype.T_DEC = 299;
|
|
PHP.Parser.prototype.T_INT_CAST = 300;
|
|
PHP.Parser.prototype.T_DOUBLE_CAST = 301;
|
|
PHP.Parser.prototype.T_STRING_CAST = 302;
|
|
PHP.Parser.prototype.T_ARRAY_CAST = 303;
|
|
PHP.Parser.prototype.T_OBJECT_CAST = 304;
|
|
PHP.Parser.prototype.T_BOOL_CAST = 305;
|
|
PHP.Parser.prototype.T_UNSET_CAST = 306;
|
|
PHP.Parser.prototype.T_POW = 307;
|
|
PHP.Parser.prototype.T_NEW = 308;
|
|
PHP.Parser.prototype.T_CLONE = 309;
|
|
PHP.Parser.prototype.T_EXIT = 310;
|
|
PHP.Parser.prototype.T_IF = 311;
|
|
PHP.Parser.prototype.T_ELSEIF = 312;
|
|
PHP.Parser.prototype.T_ELSE = 313;
|
|
PHP.Parser.prototype.T_ENDIF = 314;
|
|
PHP.Parser.prototype.T_LNUMBER = 315;
|
|
PHP.Parser.prototype.T_DNUMBER = 316;
|
|
PHP.Parser.prototype.T_STRING = 317;
|
|
PHP.Parser.prototype.T_STRING_VARNAME = 318;
|
|
PHP.Parser.prototype.T_VARIABLE = 319;
|
|
PHP.Parser.prototype.T_NUM_STRING = 320;
|
|
PHP.Parser.prototype.T_INLINE_HTML = 321;
|
|
PHP.Parser.prototype.T_ENCAPSED_AND_WHITESPACE = 322;
|
|
PHP.Parser.prototype.T_CONSTANT_ENCAPSED_STRING = 323;
|
|
PHP.Parser.prototype.T_ECHO = 324;
|
|
PHP.Parser.prototype.T_DO = 325;
|
|
PHP.Parser.prototype.T_WHILE = 326;
|
|
PHP.Parser.prototype.T_ENDWHILE = 327;
|
|
PHP.Parser.prototype.T_FOR = 328;
|
|
PHP.Parser.prototype.T_ENDFOR = 329;
|
|
PHP.Parser.prototype.T_FOREACH = 330;
|
|
PHP.Parser.prototype.T_ENDFOREACH = 331;
|
|
PHP.Parser.prototype.T_DECLARE = 332;
|
|
PHP.Parser.prototype.T_ENDDECLARE = 333;
|
|
PHP.Parser.prototype.T_AS = 334;
|
|
PHP.Parser.prototype.T_SWITCH = 335;
|
|
PHP.Parser.prototype.T_MATCH = 336;
|
|
PHP.Parser.prototype.T_ENDSWITCH = 337;
|
|
PHP.Parser.prototype.T_CASE = 338;
|
|
PHP.Parser.prototype.T_DEFAULT = 339;
|
|
PHP.Parser.prototype.T_BREAK = 340;
|
|
PHP.Parser.prototype.T_CONTINUE = 341;
|
|
PHP.Parser.prototype.T_GOTO = 342;
|
|
PHP.Parser.prototype.T_FUNCTION = 343;
|
|
PHP.Parser.prototype.T_FN = 344;
|
|
PHP.Parser.prototype.T_CONST = 345;
|
|
PHP.Parser.prototype.T_RETURN = 346;
|
|
PHP.Parser.prototype.T_TRY = 347;
|
|
PHP.Parser.prototype.T_CATCH = 348;
|
|
PHP.Parser.prototype.T_FINALLY = 349;
|
|
PHP.Parser.prototype.T_USE = 350;
|
|
PHP.Parser.prototype.T_INSTEADOF = 351;
|
|
PHP.Parser.prototype.T_GLOBAL = 352;
|
|
PHP.Parser.prototype.T_STATIC = 353;
|
|
PHP.Parser.prototype.T_ABSTRACT = 354;
|
|
PHP.Parser.prototype.T_FINAL = 355;
|
|
PHP.Parser.prototype.T_PRIVATE = 356;
|
|
PHP.Parser.prototype.T_PROTECTED = 357;
|
|
PHP.Parser.prototype.T_PUBLIC = 358;
|
|
PHP.Parser.prototype.T_READONLY = 359;
|
|
PHP.Parser.prototype.T_VAR = 360;
|
|
PHP.Parser.prototype.T_UNSET = 361;
|
|
PHP.Parser.prototype.T_ISSET = 362;
|
|
PHP.Parser.prototype.T_EMPTY = 363;
|
|
PHP.Parser.prototype.T_HALT_COMPILER = 364;
|
|
PHP.Parser.prototype.T_CLASS = 365;
|
|
PHP.Parser.prototype.T_TRAIT = 366;
|
|
PHP.Parser.prototype.T_INTERFACE = 367;
|
|
PHP.Parser.prototype.T_ENUM = 368;
|
|
PHP.Parser.prototype.T_EXTENDS = 369;
|
|
PHP.Parser.prototype.T_IMPLEMENTS = 370;
|
|
PHP.Parser.prototype.T_OBJECT_OPERATOR = 371;
|
|
PHP.Parser.prototype.T_NULLSAFE_OBJECT_OPERATOR = 372;
|
|
PHP.Parser.prototype.T_LIST = 373;
|
|
PHP.Parser.prototype.T_ARRAY = 374;
|
|
PHP.Parser.prototype.T_CALLABLE = 375;
|
|
PHP.Parser.prototype.T_CLASS_C = 376;
|
|
PHP.Parser.prototype.T_TRAIT_C = 377;
|
|
PHP.Parser.prototype.T_METHOD_C = 378;
|
|
PHP.Parser.prototype.T_FUNC_C = 379;
|
|
PHP.Parser.prototype.T_LINE = 380;
|
|
PHP.Parser.prototype.T_FILE = 381;
|
|
PHP.Parser.prototype.T_START_HEREDOC = 382;
|
|
PHP.Parser.prototype.T_END_HEREDOC = 383;
|
|
PHP.Parser.prototype.T_DOLLAR_OPEN_CURLY_BRACES = 384;
|
|
PHP.Parser.prototype.T_CURLY_OPEN = 385;
|
|
PHP.Parser.prototype.T_PAAMAYIM_NEKUDOTAYIM = 386;
|
|
PHP.Parser.prototype.T_NAMESPACE = 387;
|
|
PHP.Parser.prototype.T_NS_C = 388;
|
|
PHP.Parser.prototype.T_DIR = 389;
|
|
PHP.Parser.prototype.T_NS_SEPARATOR = 390;
|
|
PHP.Parser.prototype.T_ELLIPSIS = 391;
|
|
PHP.Parser.prototype.T_NAME_FULLY_QUALIFIED = 392;
|
|
PHP.Parser.prototype.T_NAME_QUALIFIED = 393;
|
|
PHP.Parser.prototype.T_NAME_RELATIVE = 394;
|
|
PHP.Parser.prototype.T_ATTRIBUTE = 395;
|
|
PHP.Parser.prototype.T_BAD_CHARACTER = 396;
|
|
PHP.Parser.prototype.T_COMMENT = 397;
|
|
PHP.Parser.prototype.T_DOC_COMMENT = 398;
|
|
PHP.Parser.prototype.T_OPEN_TAG = 399;
|
|
PHP.Parser.prototype.T_OPEN_TAG_WITH_ECHO = 400;
|
|
PHP.Parser.prototype.T_CLOSE_TAG = 401;
|
|
PHP.Parser.prototype.T_WHITESPACE = 402;
|
|
// }}}
|
|
/* @var array Map of token ids to their respective names */ PHP.Parser.prototype.terminals = [
|
|
"EOF",
|
|
"error",
|
|
"T_THROW",
|
|
"T_INCLUDE",
|
|
"T_INCLUDE_ONCE",
|
|
"T_EVAL",
|
|
"T_REQUIRE",
|
|
"T_REQUIRE_ONCE",
|
|
"','",
|
|
"T_LOGICAL_OR",
|
|
"T_LOGICAL_XOR",
|
|
"T_LOGICAL_AND",
|
|
"T_PRINT",
|
|
"T_YIELD",
|
|
"T_DOUBLE_ARROW",
|
|
"T_YIELD_FROM",
|
|
"'='",
|
|
"T_PLUS_EQUAL",
|
|
"T_MINUS_EQUAL",
|
|
"T_MUL_EQUAL",
|
|
"T_DIV_EQUAL",
|
|
"T_CONCAT_EQUAL",
|
|
"T_MOD_EQUAL",
|
|
"T_AND_EQUAL",
|
|
"T_OR_EQUAL",
|
|
"T_XOR_EQUAL",
|
|
"T_SL_EQUAL",
|
|
"T_SR_EQUAL",
|
|
"T_POW_EQUAL",
|
|
"T_COALESCE_EQUAL",
|
|
"'?'",
|
|
"':'",
|
|
"T_COALESCE",
|
|
"T_BOOLEAN_OR",
|
|
"T_BOOLEAN_AND",
|
|
"'|'",
|
|
"'^'",
|
|
"T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG",
|
|
"T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG",
|
|
"T_IS_EQUAL",
|
|
"T_IS_NOT_EQUAL",
|
|
"T_IS_IDENTICAL",
|
|
"T_IS_NOT_IDENTICAL",
|
|
"T_SPACESHIP",
|
|
"'<'",
|
|
"T_IS_SMALLER_OR_EQUAL",
|
|
"'>'",
|
|
"T_IS_GREATER_OR_EQUAL",
|
|
"T_SL",
|
|
"T_SR",
|
|
"'+'",
|
|
"'-'",
|
|
"'.'",
|
|
"'*'",
|
|
"'/'",
|
|
"'%'",
|
|
"'!'",
|
|
"T_INSTANCEOF",
|
|
"'~'",
|
|
"T_INC",
|
|
"T_DEC",
|
|
"T_INT_CAST",
|
|
"T_DOUBLE_CAST",
|
|
"T_STRING_CAST",
|
|
"T_ARRAY_CAST",
|
|
"T_OBJECT_CAST",
|
|
"T_BOOL_CAST",
|
|
"T_UNSET_CAST",
|
|
"'@'",
|
|
"T_POW",
|
|
"'['",
|
|
"T_NEW",
|
|
"T_CLONE",
|
|
"T_EXIT",
|
|
"T_IF",
|
|
"T_ELSEIF",
|
|
"T_ELSE",
|
|
"T_ENDIF",
|
|
"T_LNUMBER",
|
|
"T_DNUMBER",
|
|
"T_STRING",
|
|
"T_STRING_VARNAME",
|
|
"T_VARIABLE",
|
|
"T_NUM_STRING",
|
|
"T_INLINE_HTML",
|
|
"T_ENCAPSED_AND_WHITESPACE",
|
|
"T_CONSTANT_ENCAPSED_STRING",
|
|
"T_ECHO",
|
|
"T_DO",
|
|
"T_WHILE",
|
|
"T_ENDWHILE",
|
|
"T_FOR",
|
|
"T_ENDFOR",
|
|
"T_FOREACH",
|
|
"T_ENDFOREACH",
|
|
"T_DECLARE",
|
|
"T_ENDDECLARE",
|
|
"T_AS",
|
|
"T_SWITCH",
|
|
"T_MATCH",
|
|
"T_ENDSWITCH",
|
|
"T_CASE",
|
|
"T_DEFAULT",
|
|
"T_BREAK",
|
|
"T_CONTINUE",
|
|
"T_GOTO",
|
|
"T_FUNCTION",
|
|
"T_FN",
|
|
"T_CONST",
|
|
"T_RETURN",
|
|
"T_TRY",
|
|
"T_CATCH",
|
|
"T_FINALLY",
|
|
"T_USE",
|
|
"T_INSTEADOF",
|
|
"T_GLOBAL",
|
|
"T_STATIC",
|
|
"T_ABSTRACT",
|
|
"T_FINAL",
|
|
"T_PRIVATE",
|
|
"T_PROTECTED",
|
|
"T_PUBLIC",
|
|
"T_READONLY",
|
|
"T_VAR",
|
|
"T_UNSET",
|
|
"T_ISSET",
|
|
"T_EMPTY",
|
|
"T_HALT_COMPILER",
|
|
"T_CLASS",
|
|
"T_TRAIT",
|
|
"T_INTERFACE",
|
|
"T_ENUM",
|
|
"T_EXTENDS",
|
|
"T_IMPLEMENTS",
|
|
"T_OBJECT_OPERATOR",
|
|
"T_NULLSAFE_OBJECT_OPERATOR",
|
|
"T_LIST",
|
|
"T_ARRAY",
|
|
"T_CALLABLE",
|
|
"T_CLASS_C",
|
|
"T_TRAIT_C",
|
|
"T_METHOD_C",
|
|
"T_FUNC_C",
|
|
"T_LINE",
|
|
"T_FILE",
|
|
"T_START_HEREDOC",
|
|
"T_END_HEREDOC",
|
|
"T_DOLLAR_OPEN_CURLY_BRACES",
|
|
"T_CURLY_OPEN",
|
|
"T_PAAMAYIM_NEKUDOTAYIM",
|
|
"T_NAMESPACE",
|
|
"T_NS_C",
|
|
"T_DIR",
|
|
"T_NS_SEPARATOR",
|
|
"T_ELLIPSIS",
|
|
"T_NAME_FULLY_QUALIFIED",
|
|
"T_NAME_QUALIFIED",
|
|
"T_NAME_RELATIVE",
|
|
"T_ATTRIBUTE",
|
|
"';'",
|
|
"']'",
|
|
"'{'",
|
|
"'}'",
|
|
"'('",
|
|
"')'",
|
|
"'`'",
|
|
"'\"'",
|
|
"'$'",
|
|
"T_BAD_CHARACTER",
|
|
"T_COMMENT",
|
|
"T_DOC_COMMENT",
|
|
"T_OPEN_TAG",
|
|
"T_OPEN_TAG_WITH_ECHO",
|
|
"T_CLOSE_TAG",
|
|
"T_WHITESPACE",
|
|
"???"
|
|
];
|
|
/* @var Map which translates lexer tokens to internal tokens */ PHP.Parser.prototype.translate = [
|
|
0,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
56,
|
|
166,
|
|
175,
|
|
167,
|
|
55,
|
|
175,
|
|
175,
|
|
163,
|
|
164,
|
|
53,
|
|
50,
|
|
8,
|
|
51,
|
|
52,
|
|
54,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
31,
|
|
159,
|
|
44,
|
|
16,
|
|
46,
|
|
30,
|
|
68,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
70,
|
|
175,
|
|
160,
|
|
36,
|
|
175,
|
|
165,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
161,
|
|
35,
|
|
162,
|
|
58,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
175,
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
9,
|
|
10,
|
|
11,
|
|
12,
|
|
13,
|
|
14,
|
|
15,
|
|
17,
|
|
18,
|
|
19,
|
|
20,
|
|
21,
|
|
22,
|
|
23,
|
|
24,
|
|
25,
|
|
26,
|
|
27,
|
|
28,
|
|
29,
|
|
32,
|
|
33,
|
|
34,
|
|
37,
|
|
38,
|
|
39,
|
|
40,
|
|
41,
|
|
42,
|
|
43,
|
|
45,
|
|
47,
|
|
48,
|
|
49,
|
|
57,
|
|
59,
|
|
60,
|
|
61,
|
|
62,
|
|
63,
|
|
64,
|
|
65,
|
|
66,
|
|
67,
|
|
69,
|
|
71,
|
|
72,
|
|
73,
|
|
74,
|
|
75,
|
|
76,
|
|
77,
|
|
78,
|
|
79,
|
|
80,
|
|
81,
|
|
82,
|
|
83,
|
|
84,
|
|
85,
|
|
86,
|
|
87,
|
|
88,
|
|
89,
|
|
90,
|
|
91,
|
|
92,
|
|
93,
|
|
94,
|
|
95,
|
|
96,
|
|
97,
|
|
98,
|
|
99,
|
|
100,
|
|
101,
|
|
102,
|
|
103,
|
|
104,
|
|
105,
|
|
106,
|
|
107,
|
|
108,
|
|
109,
|
|
110,
|
|
111,
|
|
112,
|
|
113,
|
|
114,
|
|
115,
|
|
116,
|
|
117,
|
|
118,
|
|
119,
|
|
120,
|
|
121,
|
|
122,
|
|
123,
|
|
124,
|
|
125,
|
|
126,
|
|
127,
|
|
128,
|
|
129,
|
|
130,
|
|
131,
|
|
132,
|
|
133,
|
|
134,
|
|
135,
|
|
136,
|
|
137,
|
|
138,
|
|
139,
|
|
140,
|
|
141,
|
|
142,
|
|
143,
|
|
144,
|
|
145,
|
|
146,
|
|
147,
|
|
148,
|
|
149,
|
|
150,
|
|
151,
|
|
152,
|
|
153,
|
|
154,
|
|
155,
|
|
156,
|
|
157,
|
|
158,
|
|
168,
|
|
169,
|
|
170,
|
|
171,
|
|
172,
|
|
173,
|
|
174
|
|
];
|
|
PHP.Parser.prototype.yyaction = [
|
|
132,
|
|
133,
|
|
134,
|
|
569,
|
|
135,
|
|
136,
|
|
0,
|
|
722,
|
|
723,
|
|
724,
|
|
137,
|
|
37,
|
|
834,
|
|
911,
|
|
835,
|
|
469,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32767,
|
|
-32767,
|
|
-32767,
|
|
-32767,
|
|
101,
|
|
102,
|
|
103,
|
|
104,
|
|
105,
|
|
1068,
|
|
1069,
|
|
1070,
|
|
1067,
|
|
1066,
|
|
1065,
|
|
1071,
|
|
716,
|
|
715,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32767,
|
|
-32767,
|
|
-32767,
|
|
-32767,
|
|
-32767,
|
|
545,
|
|
546,
|
|
-32766,
|
|
-32766,
|
|
725,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
998,
|
|
999,
|
|
806,
|
|
922,
|
|
447,
|
|
448,
|
|
449,
|
|
370,
|
|
371,
|
|
2,
|
|
267,
|
|
138,
|
|
396,
|
|
729,
|
|
730,
|
|
731,
|
|
732,
|
|
414,
|
|
-32766,
|
|
420,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
990,
|
|
733,
|
|
734,
|
|
735,
|
|
736,
|
|
737,
|
|
738,
|
|
739,
|
|
740,
|
|
741,
|
|
742,
|
|
743,
|
|
763,
|
|
570,
|
|
764,
|
|
765,
|
|
766,
|
|
767,
|
|
755,
|
|
756,
|
|
336,
|
|
337,
|
|
758,
|
|
759,
|
|
744,
|
|
745,
|
|
746,
|
|
748,
|
|
749,
|
|
750,
|
|
346,
|
|
790,
|
|
791,
|
|
792,
|
|
793,
|
|
794,
|
|
795,
|
|
751,
|
|
752,
|
|
571,
|
|
572,
|
|
784,
|
|
775,
|
|
773,
|
|
774,
|
|
787,
|
|
770,
|
|
771,
|
|
283,
|
|
420,
|
|
573,
|
|
574,
|
|
769,
|
|
575,
|
|
576,
|
|
577,
|
|
578,
|
|
579,
|
|
580,
|
|
598,
|
|
-575,
|
|
470,
|
|
14,
|
|
798,
|
|
772,
|
|
581,
|
|
582,
|
|
-575,
|
|
139,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
132,
|
|
133,
|
|
134,
|
|
569,
|
|
135,
|
|
136,
|
|
1017,
|
|
722,
|
|
723,
|
|
724,
|
|
137,
|
|
37,
|
|
1060,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
1303,
|
|
696,
|
|
-32766,
|
|
1304,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
1068,
|
|
1069,
|
|
1070,
|
|
1067,
|
|
1066,
|
|
1065,
|
|
1071,
|
|
-32766,
|
|
716,
|
|
715,
|
|
372,
|
|
371,
|
|
1258,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-572,
|
|
106,
|
|
107,
|
|
108,
|
|
414,
|
|
270,
|
|
891,
|
|
-572,
|
|
240,
|
|
1193,
|
|
1192,
|
|
1194,
|
|
725,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
1046,
|
|
109,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
986,
|
|
985,
|
|
984,
|
|
987,
|
|
267,
|
|
138,
|
|
396,
|
|
729,
|
|
730,
|
|
731,
|
|
732,
|
|
12,
|
|
-32766,
|
|
420,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
998,
|
|
999,
|
|
733,
|
|
734,
|
|
735,
|
|
736,
|
|
737,
|
|
738,
|
|
739,
|
|
740,
|
|
741,
|
|
742,
|
|
743,
|
|
763,
|
|
570,
|
|
764,
|
|
765,
|
|
766,
|
|
767,
|
|
755,
|
|
756,
|
|
336,
|
|
337,
|
|
758,
|
|
759,
|
|
744,
|
|
745,
|
|
746,
|
|
748,
|
|
749,
|
|
750,
|
|
346,
|
|
790,
|
|
791,
|
|
792,
|
|
793,
|
|
794,
|
|
795,
|
|
751,
|
|
752,
|
|
571,
|
|
572,
|
|
784,
|
|
775,
|
|
773,
|
|
774,
|
|
787,
|
|
770,
|
|
771,
|
|
881,
|
|
321,
|
|
573,
|
|
574,
|
|
769,
|
|
575,
|
|
576,
|
|
577,
|
|
578,
|
|
579,
|
|
580,
|
|
-32766,
|
|
82,
|
|
83,
|
|
84,
|
|
-575,
|
|
772,
|
|
581,
|
|
582,
|
|
-575,
|
|
148,
|
|
747,
|
|
717,
|
|
718,
|
|
719,
|
|
720,
|
|
721,
|
|
1278,
|
|
722,
|
|
723,
|
|
724,
|
|
760,
|
|
761,
|
|
36,
|
|
1277,
|
|
85,
|
|
86,
|
|
87,
|
|
88,
|
|
89,
|
|
90,
|
|
91,
|
|
92,
|
|
93,
|
|
94,
|
|
95,
|
|
96,
|
|
97,
|
|
98,
|
|
99,
|
|
100,
|
|
101,
|
|
102,
|
|
103,
|
|
104,
|
|
105,
|
|
106,
|
|
107,
|
|
108,
|
|
996,
|
|
270,
|
|
150,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
455,
|
|
456,
|
|
81,
|
|
34,
|
|
-264,
|
|
-572,
|
|
1016,
|
|
109,
|
|
320,
|
|
-572,
|
|
893,
|
|
725,
|
|
682,
|
|
803,
|
|
128,
|
|
998,
|
|
999,
|
|
592,
|
|
-32766,
|
|
1044,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
809,
|
|
151,
|
|
726,
|
|
727,
|
|
728,
|
|
729,
|
|
730,
|
|
731,
|
|
732,
|
|
-88,
|
|
1198,
|
|
796,
|
|
278,
|
|
-526,
|
|
283,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
733,
|
|
734,
|
|
735,
|
|
736,
|
|
737,
|
|
738,
|
|
739,
|
|
740,
|
|
741,
|
|
742,
|
|
743,
|
|
763,
|
|
786,
|
|
764,
|
|
765,
|
|
766,
|
|
767,
|
|
755,
|
|
756,
|
|
757,
|
|
785,
|
|
758,
|
|
759,
|
|
744,
|
|
745,
|
|
746,
|
|
748,
|
|
749,
|
|
750,
|
|
789,
|
|
790,
|
|
791,
|
|
792,
|
|
793,
|
|
794,
|
|
795,
|
|
751,
|
|
752,
|
|
753,
|
|
754,
|
|
784,
|
|
775,
|
|
773,
|
|
774,
|
|
787,
|
|
770,
|
|
771,
|
|
144,
|
|
804,
|
|
762,
|
|
768,
|
|
769,
|
|
776,
|
|
777,
|
|
779,
|
|
778,
|
|
780,
|
|
781,
|
|
-314,
|
|
-526,
|
|
-526,
|
|
-193,
|
|
-192,
|
|
772,
|
|
783,
|
|
782,
|
|
49,
|
|
50,
|
|
51,
|
|
500,
|
|
52,
|
|
53,
|
|
239,
|
|
807,
|
|
-526,
|
|
-86,
|
|
54,
|
|
55,
|
|
-111,
|
|
56,
|
|
996,
|
|
253,
|
|
-32766,
|
|
-111,
|
|
800,
|
|
-111,
|
|
-526,
|
|
541,
|
|
-532,
|
|
-352,
|
|
300,
|
|
-352,
|
|
304,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
998,
|
|
999,
|
|
998,
|
|
999,
|
|
153,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
1191,
|
|
807,
|
|
126,
|
|
306,
|
|
1293,
|
|
57,
|
|
58,
|
|
103,
|
|
104,
|
|
105,
|
|
-111,
|
|
59,
|
|
1218,
|
|
60,
|
|
246,
|
|
247,
|
|
61,
|
|
62,
|
|
63,
|
|
64,
|
|
65,
|
|
66,
|
|
67,
|
|
68,
|
|
-525,
|
|
27,
|
|
268,
|
|
69,
|
|
436,
|
|
501,
|
|
-328,
|
|
808,
|
|
-86,
|
|
1224,
|
|
1225,
|
|
502,
|
|
1189,
|
|
807,
|
|
1198,
|
|
1230,
|
|
293,
|
|
1222,
|
|
41,
|
|
24,
|
|
503,
|
|
74,
|
|
504,
|
|
953,
|
|
505,
|
|
320,
|
|
506,
|
|
802,
|
|
154,
|
|
507,
|
|
508,
|
|
279,
|
|
684,
|
|
280,
|
|
43,
|
|
44,
|
|
437,
|
|
367,
|
|
366,
|
|
891,
|
|
45,
|
|
509,
|
|
35,
|
|
249,
|
|
-16,
|
|
-566,
|
|
358,
|
|
332,
|
|
318,
|
|
-566,
|
|
1198,
|
|
1193,
|
|
1192,
|
|
1194,
|
|
-527,
|
|
510,
|
|
511,
|
|
512,
|
|
333,
|
|
-524,
|
|
1274,
|
|
48,
|
|
716,
|
|
715,
|
|
-525,
|
|
-525,
|
|
334,
|
|
513,
|
|
514,
|
|
807,
|
|
1212,
|
|
1213,
|
|
1214,
|
|
1215,
|
|
1209,
|
|
1210,
|
|
292,
|
|
360,
|
|
284,
|
|
-525,
|
|
285,
|
|
-314,
|
|
1216,
|
|
1211,
|
|
-193,
|
|
-192,
|
|
1193,
|
|
1192,
|
|
1194,
|
|
293,
|
|
891,
|
|
-525,
|
|
364,
|
|
-531,
|
|
70,
|
|
807,
|
|
316,
|
|
317,
|
|
320,
|
|
31,
|
|
110,
|
|
111,
|
|
112,
|
|
113,
|
|
114,
|
|
115,
|
|
116,
|
|
117,
|
|
118,
|
|
119,
|
|
120,
|
|
121,
|
|
122,
|
|
-153,
|
|
-153,
|
|
-153,
|
|
638,
|
|
25,
|
|
-527,
|
|
-527,
|
|
687,
|
|
379,
|
|
881,
|
|
-524,
|
|
-524,
|
|
296,
|
|
297,
|
|
891,
|
|
-153,
|
|
432,
|
|
-153,
|
|
807,
|
|
-153,
|
|
-527,
|
|
-153,
|
|
716,
|
|
715,
|
|
433,
|
|
-524,
|
|
798,
|
|
363,
|
|
-111,
|
|
1105,
|
|
1107,
|
|
365,
|
|
-527,
|
|
434,
|
|
891,
|
|
140,
|
|
435,
|
|
-524,
|
|
954,
|
|
127,
|
|
-524,
|
|
320,
|
|
-111,
|
|
-111,
|
|
688,
|
|
813,
|
|
381,
|
|
-529,
|
|
11,
|
|
834,
|
|
155,
|
|
835,
|
|
867,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
47,
|
|
293,
|
|
-32766,
|
|
881,
|
|
654,
|
|
655,
|
|
74,
|
|
689,
|
|
1191,
|
|
1045,
|
|
320,
|
|
708,
|
|
149,
|
|
399,
|
|
157,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
32,
|
|
-32766,
|
|
-79,
|
|
-32766,
|
|
123,
|
|
-32766,
|
|
716,
|
|
715,
|
|
-32766,
|
|
893,
|
|
891,
|
|
682,
|
|
-153,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
716,
|
|
715,
|
|
891,
|
|
-32766,
|
|
-32766,
|
|
124,
|
|
881,
|
|
129,
|
|
74,
|
|
-32766,
|
|
411,
|
|
130,
|
|
320,
|
|
-524,
|
|
-524,
|
|
143,
|
|
141,
|
|
-75,
|
|
-32766,
|
|
158,
|
|
-529,
|
|
-529,
|
|
320,
|
|
27,
|
|
691,
|
|
159,
|
|
881,
|
|
160,
|
|
-524,
|
|
161,
|
|
294,
|
|
295,
|
|
698,
|
|
368,
|
|
369,
|
|
807,
|
|
-73,
|
|
-32766,
|
|
-72,
|
|
1222,
|
|
-524,
|
|
373,
|
|
374,
|
|
1191,
|
|
893,
|
|
-71,
|
|
682,
|
|
-529,
|
|
73,
|
|
-70,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-69,
|
|
-32766,
|
|
-68,
|
|
-32766,
|
|
125,
|
|
-32766,
|
|
630,
|
|
631,
|
|
-32766,
|
|
-67,
|
|
-66,
|
|
-47,
|
|
-51,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-18,
|
|
147,
|
|
271,
|
|
-32766,
|
|
-32766,
|
|
277,
|
|
697,
|
|
700,
|
|
881,
|
|
-32766,
|
|
411,
|
|
890,
|
|
893,
|
|
146,
|
|
682,
|
|
282,
|
|
881,
|
|
907,
|
|
-32766,
|
|
281,
|
|
513,
|
|
514,
|
|
286,
|
|
1212,
|
|
1213,
|
|
1214,
|
|
1215,
|
|
1209,
|
|
1210,
|
|
326,
|
|
131,
|
|
145,
|
|
939,
|
|
287,
|
|
682,
|
|
1216,
|
|
1211,
|
|
109,
|
|
270,
|
|
-32766,
|
|
798,
|
|
807,
|
|
-32766,
|
|
662,
|
|
639,
|
|
1191,
|
|
657,
|
|
72,
|
|
675,
|
|
1075,
|
|
317,
|
|
320,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
1305,
|
|
-32766,
|
|
301,
|
|
-32766,
|
|
628,
|
|
-32766,
|
|
431,
|
|
543,
|
|
-32766,
|
|
-32766,
|
|
923,
|
|
555,
|
|
924,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
1229,
|
|
549,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-4,
|
|
891,
|
|
-490,
|
|
1191,
|
|
-32766,
|
|
411,
|
|
644,
|
|
893,
|
|
299,
|
|
682,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
893,
|
|
-32766,
|
|
682,
|
|
-32766,
|
|
13,
|
|
1231,
|
|
-32766,
|
|
452,
|
|
480,
|
|
645,
|
|
909,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
658,
|
|
-480,
|
|
-32766,
|
|
-32766,
|
|
0,
|
|
1191,
|
|
0,
|
|
0,
|
|
-32766,
|
|
411,
|
|
0,
|
|
298,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
305,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
0,
|
|
-32766,
|
|
0,
|
|
806,
|
|
-32766,
|
|
0,
|
|
0,
|
|
0,
|
|
475,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
0,
|
|
7,
|
|
-32766,
|
|
-32766,
|
|
16,
|
|
1191,
|
|
561,
|
|
596,
|
|
-32766,
|
|
411,
|
|
1219,
|
|
891,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
362,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
818,
|
|
-32766,
|
|
-267,
|
|
881,
|
|
-32766,
|
|
39,
|
|
293,
|
|
0,
|
|
0,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
40,
|
|
705,
|
|
706,
|
|
-32766,
|
|
-32766,
|
|
872,
|
|
963,
|
|
940,
|
|
947,
|
|
-32766,
|
|
411,
|
|
937,
|
|
948,
|
|
365,
|
|
870,
|
|
427,
|
|
891,
|
|
935,
|
|
-32766,
|
|
1049,
|
|
291,
|
|
1244,
|
|
1052,
|
|
1053,
|
|
-111,
|
|
-111,
|
|
1050,
|
|
1051,
|
|
1057,
|
|
-560,
|
|
1262,
|
|
1296,
|
|
633,
|
|
0,
|
|
826,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
33,
|
|
315,
|
|
-32766,
|
|
361,
|
|
683,
|
|
686,
|
|
690,
|
|
692,
|
|
1191,
|
|
693,
|
|
694,
|
|
695,
|
|
699,
|
|
685,
|
|
320,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
9,
|
|
-32766,
|
|
702,
|
|
-32766,
|
|
868,
|
|
-32766,
|
|
881,
|
|
1300,
|
|
-32766,
|
|
893,
|
|
1302,
|
|
682,
|
|
-4,
|
|
-32766,
|
|
-32766,
|
|
-32766,
|
|
829,
|
|
828,
|
|
837,
|
|
-32766,
|
|
-32766,
|
|
916,
|
|
-242,
|
|
-242,
|
|
-242,
|
|
-32766,
|
|
411,
|
|
955,
|
|
365,
|
|
27,
|
|
836,
|
|
1301,
|
|
915,
|
|
917,
|
|
-32766,
|
|
914,
|
|
1177,
|
|
900,
|
|
910,
|
|
-111,
|
|
-111,
|
|
807,
|
|
881,
|
|
898,
|
|
945,
|
|
1222,
|
|
946,
|
|
1299,
|
|
1256,
|
|
867,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
1245,
|
|
1263,
|
|
1269,
|
|
1272,
|
|
-241,
|
|
-241,
|
|
-241,
|
|
-558,
|
|
-532,
|
|
-531,
|
|
365,
|
|
-530,
|
|
1,
|
|
28,
|
|
29,
|
|
38,
|
|
42,
|
|
46,
|
|
71,
|
|
0,
|
|
75,
|
|
-111,
|
|
-111,
|
|
76,
|
|
77,
|
|
78,
|
|
79,
|
|
893,
|
|
80,
|
|
682,
|
|
-242,
|
|
867,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
-111,
|
|
142,
|
|
152,
|
|
156,
|
|
245,
|
|
322,
|
|
347,
|
|
514,
|
|
348,
|
|
1212,
|
|
1213,
|
|
1214,
|
|
1215,
|
|
1209,
|
|
1210,
|
|
349,
|
|
350,
|
|
351,
|
|
352,
|
|
353,
|
|
354,
|
|
1216,
|
|
1211,
|
|
355,
|
|
356,
|
|
357,
|
|
359,
|
|
428,
|
|
893,
|
|
-265,
|
|
682,
|
|
-241,
|
|
-264,
|
|
72,
|
|
0,
|
|
18,
|
|
317,
|
|
320,
|
|
19,
|
|
20,
|
|
21,
|
|
23,
|
|
398,
|
|
471,
|
|
472,
|
|
479,
|
|
482,
|
|
483,
|
|
484,
|
|
485,
|
|
489,
|
|
490,
|
|
491,
|
|
498,
|
|
669,
|
|
1202,
|
|
1145,
|
|
1220,
|
|
1019,
|
|
1018,
|
|
1181,
|
|
-269,
|
|
-103,
|
|
17,
|
|
22,
|
|
26,
|
|
290,
|
|
397,
|
|
589,
|
|
593,
|
|
620,
|
|
674,
|
|
1149,
|
|
1197,
|
|
1146,
|
|
1275,
|
|
0,
|
|
-494,
|
|
1162,
|
|
0,
|
|
1223
|
|
];
|
|
PHP.Parser.prototype.yycheck = [
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
0,
|
|
9,
|
|
10,
|
|
11,
|
|
12,
|
|
13,
|
|
106,
|
|
1,
|
|
108,
|
|
31,
|
|
9,
|
|
10,
|
|
11,
|
|
44,
|
|
45,
|
|
46,
|
|
47,
|
|
48,
|
|
49,
|
|
50,
|
|
51,
|
|
52,
|
|
116,
|
|
117,
|
|
118,
|
|
119,
|
|
120,
|
|
121,
|
|
122,
|
|
37,
|
|
38,
|
|
30,
|
|
116,
|
|
32,
|
|
33,
|
|
34,
|
|
35,
|
|
36,
|
|
37,
|
|
38,
|
|
39,
|
|
40,
|
|
41,
|
|
42,
|
|
43,
|
|
117,
|
|
118,
|
|
9,
|
|
10,
|
|
57,
|
|
9,
|
|
10,
|
|
11,
|
|
137,
|
|
138,
|
|
155,
|
|
128,
|
|
129,
|
|
130,
|
|
131,
|
|
106,
|
|
107,
|
|
8,
|
|
71,
|
|
72,
|
|
73,
|
|
74,
|
|
75,
|
|
76,
|
|
77,
|
|
116,
|
|
30,
|
|
80,
|
|
32,
|
|
33,
|
|
34,
|
|
35,
|
|
36,
|
|
1,
|
|
87,
|
|
88,
|
|
89,
|
|
90,
|
|
91,
|
|
92,
|
|
93,
|
|
94,
|
|
95,
|
|
96,
|
|
97,
|
|
98,
|
|
99,
|
|
100,
|
|
101,
|
|
102,
|
|
103,
|
|
104,
|
|
105,
|
|
106,
|
|
107,
|
|
108,
|
|
109,
|
|
110,
|
|
111,
|
|
112,
|
|
113,
|
|
114,
|
|
115,
|
|
116,
|
|
117,
|
|
118,
|
|
119,
|
|
120,
|
|
121,
|
|
122,
|
|
123,
|
|
124,
|
|
125,
|
|
126,
|
|
127,
|
|
128,
|
|
129,
|
|
130,
|
|
131,
|
|
132,
|
|
133,
|
|
30,
|
|
80,
|
|
136,
|
|
137,
|
|
138,
|
|
139,
|
|
140,
|
|
141,
|
|
142,
|
|
143,
|
|
144,
|
|
51,
|
|
1,
|
|
161,
|
|
101,
|
|
80,
|
|
150,
|
|
151,
|
|
152,
|
|
8,
|
|
154,
|
|
9,
|
|
10,
|
|
11,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
164,
|
|
9,
|
|
10,
|
|
11,
|
|
12,
|
|
13,
|
|
123,
|
|
9,
|
|
10,
|
|
11,
|
|
80,
|
|
161,
|
|
30,
|
|
83,
|
|
32,
|
|
33,
|
|
34,
|
|
35,
|
|
36,
|
|
37,
|
|
38,
|
|
116,
|
|
117,
|
|
118,
|
|
119,
|
|
120,
|
|
121,
|
|
122,
|
|
30,
|
|
37,
|
|
38,
|
|
106,
|
|
107,
|
|
1,
|
|
9,
|
|
10,
|
|
11,
|
|
1,
|
|
53,
|
|
54,
|
|
55,
|
|
116,
|
|
57,
|
|
1,
|
|
8,
|
|
14,
|
|
155,
|
|
156,
|
|
157,
|
|
57,
|
|
9,
|
|
10,
|
|
11,
|
|
162,
|
|
69,
|
|
30,
|
|
116,
|
|
32,
|
|
33,
|
|
119,
|
|
120,
|
|
121,
|
|
122,
|
|
71,
|
|
72,
|
|
73,
|
|
74,
|
|
75,
|
|
76,
|
|
77,
|
|
8,
|
|
30,
|
|
80,
|
|
32,
|
|
33,
|
|
34,
|
|
35,
|
|
137,
|
|
138,
|
|
87,
|
|
88,
|
|
89,
|
|
90,
|
|
91,
|
|
92,
|
|
93,
|
|
94,
|
|
95,
|
|
96,
|
|
97,
|
|
98,
|
|
99,
|
|
100,
|
|
101,
|
|
102,
|
|
103,
|
|
104,
|
|
105,
|
|
106,
|
|
107,
|
|
108,
|
|
109,
|
|
110,
|
|
111,
|
|
112,
|
|
113,
|
|
114,
|
|
115,
|
|
116,
|
|
117,
|
|
118,
|
|
119,
|
|
120,
|
|
121,
|
|
122,
|
|
123,
|
|
124,
|
|
125,
|
|
126,
|
|
127,
|
|
128,
|
|
129,
|
|
130,
|
|
131,
|
|
132,
|
|
133,
|
|
84,
|
|
70,
|
|
136,
|
|
137,
|
|
138,
|
|
139,
|
|
140,
|
|
141,
|
|
142,
|
|
143,
|
|
144,
|
|
9,
|
|
9,
|
|
10,
|
|
11,
|
|
160,
|
|
150,
|
|
151,
|
|
152,
|
|
164,
|
|
154,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
1,
|
|
9,
|
|
10,
|
|
11,
|
|
12,
|
|
13,
|
|
30,
|
|
8,
|
|
32,
|
|
33,
|
|
34,
|
|
35,
|
|
36,
|
|
37,
|
|
38,
|
|
39,
|
|
40,
|
|
41,
|
|
42,
|
|
43,
|
|
44,
|
|
45,
|
|
46,
|
|
47,
|
|
48,
|
|
49,
|
|
50,
|
|
51,
|
|
52,
|
|
53,
|
|
54,
|
|
55,
|
|
116,
|
|
57,
|
|
14,
|
|
9,
|
|
10,
|
|
11,
|
|
134,
|
|
135,
|
|
161,
|
|
8,
|
|
164,
|
|
160,
|
|
1,
|
|
69,
|
|
167,
|
|
164,
|
|
159,
|
|
57,
|
|
161,
|
|
80,
|
|
8,
|
|
137,
|
|
138,
|
|
1,
|
|
30,
|
|
1,
|
|
32,
|
|
33,
|
|
34,
|
|
1,
|
|
14,
|
|
71,
|
|
72,
|
|
73,
|
|
74,
|
|
75,
|
|
76,
|
|
77,
|
|
31,
|
|
1,
|
|
80,
|
|
30,
|
|
70,
|
|
30,
|
|
9,
|
|
10,
|
|
11,
|
|
87,
|
|
88,
|
|
89,
|
|
90,
|
|
91,
|
|
92,
|
|
93,
|
|
94,
|
|
95,
|
|
96,
|
|
97,
|
|
98,
|
|
99,
|
|
100,
|
|
101,
|
|
102,
|
|
103,
|
|
104,
|
|
105,
|
|
106,
|
|
107,
|
|
108,
|
|
109,
|
|
110,
|
|
111,
|
|
112,
|
|
113,
|
|
114,
|
|
115,
|
|
116,
|
|
117,
|
|
118,
|
|
119,
|
|
120,
|
|
121,
|
|
122,
|
|
123,
|
|
124,
|
|
125,
|
|
126,
|
|
127,
|
|
128,
|
|
129,
|
|
130,
|
|
131,
|
|
132,
|
|
133,
|
|
8,
|
|
156,
|
|
136,
|
|
137,
|
|
138,
|
|
139,
|
|
140,
|
|
141,
|
|
142,
|
|
143,
|
|
144,
|
|
8,
|
|
134,
|
|
135,
|
|
8,
|
|
8,
|
|
150,
|
|
151,
|
|
152,
|
|
2,
|
|
3,
|
|
4,
|
|
5,
|
|
6,
|
|
7,
|
|
97,
|
|
82,
|
|
149,
|
|
31,
|
|
12,
|
|
13,
|
|
101,
|
|
15,
|
|
116,
|
|
8,
|
|
116,
|
|
106,
|
|
80,
|
|
108,
|
|
161,
|
|
85,
|
|
163,
|
|
106,
|
|
113,
|
|
108,
|
|
8,
|
|
116,
|
|
117,
|
|
118,
|
|
119,
|
|
120,
|
|
121,
|
|
122,
|
|
123,
|
|
137,
|
|
138,
|
|
137,
|
|
138,
|
|
14,
|
|
9,
|
|
10,
|
|
11,
|
|
80,
|
|
82,
|
|
14,
|
|
8,
|
|
85,
|
|
50,
|
|
51,
|
|
50,
|
|
51,
|
|
52,
|
|
128,
|
|
56,
|
|
1,
|
|
58,
|
|
59,
|
|
60,
|
|
61,
|
|
62,
|
|
63,
|
|
64,
|
|
65,
|
|
66,
|
|
67,
|
|
68,
|
|
70,
|
|
70,
|
|
71,
|
|
72,
|
|
73,
|
|
74,
|
|
162,
|
|
159,
|
|
97,
|
|
78,
|
|
79,
|
|
80,
|
|
116,
|
|
82,
|
|
1,
|
|
146,
|
|
158,
|
|
86,
|
|
87,
|
|
88,
|
|
89,
|
|
163,
|
|
91,
|
|
31,
|
|
93,
|
|
167,
|
|
95,
|
|
156,
|
|
14,
|
|
98,
|
|
99,
|
|
35,
|
|
161,
|
|
37,
|
|
103,
|
|
104,
|
|
105,
|
|
106,
|
|
107,
|
|
1,
|
|
109,
|
|
110,
|
|
147,
|
|
148,
|
|
31,
|
|
160,
|
|
115,
|
|
116,
|
|
8,
|
|
164,
|
|
1,
|
|
155,
|
|
156,
|
|
157,
|
|
70,
|
|
124,
|
|
125,
|
|
126,
|
|
8,
|
|
70,
|
|
1,
|
|
70,
|
|
37,
|
|
38,
|
|
134,
|
|
135,
|
|
8,
|
|
136,
|
|
137,
|
|
82,
|
|
139,
|
|
140,
|
|
141,
|
|
142,
|
|
143,
|
|
144,
|
|
145,
|
|
8,
|
|
35,
|
|
149,
|
|
37,
|
|
164,
|
|
151,
|
|
152,
|
|
164,
|
|
164,
|
|
155,
|
|
156,
|
|
157,
|
|
158,
|
|
1,
|
|
161,
|
|
8,
|
|
163,
|
|
163,
|
|
82,
|
|
165,
|
|
166,
|
|
167,
|
|
16,
|
|
17,
|
|
18,
|
|
19,
|
|
20,
|
|
21,
|
|
22,
|
|
23,
|
|
24,
|
|
25,
|
|
26,
|
|
27,
|
|
28,
|
|
29,
|
|
75,
|
|
76,
|
|
77,
|
|
75,
|
|
76,
|
|
134,
|
|
135,
|
|
31,
|
|
8,
|
|
84,
|
|
134,
|
|
135,
|
|
134,
|
|
135,
|
|
1,
|
|
90,
|
|
8,
|
|
92,
|
|
82,
|
|
94,
|
|
149,
|
|
96,
|
|
37,
|
|
38,
|
|
8,
|
|
149,
|
|
80,
|
|
149,
|
|
128,
|
|
59,
|
|
60,
|
|
106,
|
|
161,
|
|
8,
|
|
1,
|
|
161,
|
|
8,
|
|
161,
|
|
159,
|
|
161,
|
|
70,
|
|
167,
|
|
117,
|
|
118,
|
|
31,
|
|
8,
|
|
106,
|
|
70,
|
|
108,
|
|
106,
|
|
14,
|
|
108,
|
|
127,
|
|
128,
|
|
129,
|
|
130,
|
|
131,
|
|
70,
|
|
158,
|
|
74,
|
|
84,
|
|
75,
|
|
76,
|
|
163,
|
|
31,
|
|
80,
|
|
159,
|
|
167,
|
|
161,
|
|
101,
|
|
102,
|
|
14,
|
|
87,
|
|
88,
|
|
89,
|
|
14,
|
|
91,
|
|
31,
|
|
93,
|
|
16,
|
|
95,
|
|
37,
|
|
38,
|
|
98,
|
|
159,
|
|
1,
|
|
161,
|
|
162,
|
|
103,
|
|
104,
|
|
105,
|
|
37,
|
|
38,
|
|
1,
|
|
109,
|
|
110,
|
|
16,
|
|
84,
|
|
16,
|
|
163,
|
|
115,
|
|
116,
|
|
16,
|
|
167,
|
|
134,
|
|
135,
|
|
16,
|
|
161,
|
|
31,
|
|
124,
|
|
16,
|
|
134,
|
|
135,
|
|
167,
|
|
70,
|
|
31,
|
|
16,
|
|
84,
|
|
16,
|
|
149,
|
|
16,
|
|
134,
|
|
135,
|
|
31,
|
|
106,
|
|
107,
|
|
82,
|
|
31,
|
|
74,
|
|
31,
|
|
86,
|
|
161,
|
|
106,
|
|
107,
|
|
80,
|
|
159,
|
|
31,
|
|
161,
|
|
161,
|
|
154,
|
|
31,
|
|
87,
|
|
88,
|
|
89,
|
|
31,
|
|
91,
|
|
31,
|
|
93,
|
|
161,
|
|
95,
|
|
111,
|
|
112,
|
|
98,
|
|
31,
|
|
31,
|
|
31,
|
|
31,
|
|
103,
|
|
104,
|
|
105,
|
|
31,
|
|
31,
|
|
31,
|
|
109,
|
|
110,
|
|
31,
|
|
31,
|
|
31,
|
|
84,
|
|
115,
|
|
116,
|
|
31,
|
|
159,
|
|
31,
|
|
161,
|
|
37,
|
|
84,
|
|
38,
|
|
124,
|
|
35,
|
|
136,
|
|
137,
|
|
35,
|
|
139,
|
|
140,
|
|
141,
|
|
142,
|
|
143,
|
|
144,
|
|
35,
|
|
31,
|
|
70,
|
|
159,
|
|
37,
|
|
161,
|
|
151,
|
|
152,
|
|
69,
|
|
57,
|
|
74,
|
|
80,
|
|
82,
|
|
85,
|
|
77,
|
|
90,
|
|
80,
|
|
94,
|
|
163,
|
|
92,
|
|
82,
|
|
166,
|
|
167,
|
|
87,
|
|
88,
|
|
89,
|
|
83,
|
|
91,
|
|
114,
|
|
93,
|
|
113,
|
|
95,
|
|
128,
|
|
85,
|
|
98,
|
|
116,
|
|
128,
|
|
153,
|
|
128,
|
|
103,
|
|
104,
|
|
105,
|
|
146,
|
|
89,
|
|
74,
|
|
109,
|
|
110,
|
|
0,
|
|
1,
|
|
149,
|
|
80,
|
|
115,
|
|
116,
|
|
96,
|
|
159,
|
|
133,
|
|
161,
|
|
87,
|
|
88,
|
|
89,
|
|
124,
|
|
91,
|
|
159,
|
|
93,
|
|
161,
|
|
95,
|
|
97,
|
|
146,
|
|
98,
|
|
97,
|
|
97,
|
|
100,
|
|
154,
|
|
103,
|
|
104,
|
|
105,
|
|
74,
|
|
100,
|
|
149,
|
|
109,
|
|
110,
|
|
-1,
|
|
80,
|
|
-1,
|
|
-1,
|
|
115,
|
|
116,
|
|
-1,
|
|
132,
|
|
87,
|
|
88,
|
|
89,
|
|
132,
|
|
91,
|
|
124,
|
|
93,
|
|
-1,
|
|
95,
|
|
-1,
|
|
155,
|
|
98,
|
|
-1,
|
|
-1,
|
|
-1,
|
|
102,
|
|
103,
|
|
104,
|
|
105,
|
|
74,
|
|
-1,
|
|
149,
|
|
109,
|
|
110,
|
|
149,
|
|
80,
|
|
81,
|
|
153,
|
|
115,
|
|
116,
|
|
160,
|
|
1,
|
|
87,
|
|
88,
|
|
89,
|
|
149,
|
|
91,
|
|
124,
|
|
93,
|
|
160,
|
|
95,
|
|
164,
|
|
84,
|
|
98,
|
|
159,
|
|
158,
|
|
-1,
|
|
-1,
|
|
103,
|
|
104,
|
|
105,
|
|
159,
|
|
159,
|
|
159,
|
|
109,
|
|
110,
|
|
159,
|
|
159,
|
|
159,
|
|
159,
|
|
115,
|
|
116,
|
|
159,
|
|
159,
|
|
106,
|
|
159,
|
|
108,
|
|
1,
|
|
159,
|
|
124,
|
|
159,
|
|
113,
|
|
160,
|
|
159,
|
|
159,
|
|
117,
|
|
118,
|
|
159,
|
|
159,
|
|
159,
|
|
163,
|
|
160,
|
|
160,
|
|
160,
|
|
-1,
|
|
127,
|
|
128,
|
|
129,
|
|
130,
|
|
131,
|
|
161,
|
|
161,
|
|
74,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
80,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
167,
|
|
87,
|
|
88,
|
|
89,
|
|
150,
|
|
91,
|
|
162,
|
|
93,
|
|
162,
|
|
95,
|
|
84,
|
|
162,
|
|
98,
|
|
159,
|
|
162,
|
|
161,
|
|
162,
|
|
103,
|
|
104,
|
|
105,
|
|
162,
|
|
162,
|
|
162,
|
|
109,
|
|
110,
|
|
162,
|
|
100,
|
|
101,
|
|
102,
|
|
115,
|
|
116,
|
|
162,
|
|
106,
|
|
70,
|
|
162,
|
|
162,
|
|
162,
|
|
162,
|
|
124,
|
|
162,
|
|
162,
|
|
162,
|
|
162,
|
|
117,
|
|
118,
|
|
82,
|
|
84,
|
|
162,
|
|
162,
|
|
86,
|
|
162,
|
|
162,
|
|
162,
|
|
127,
|
|
128,
|
|
129,
|
|
130,
|
|
131,
|
|
162,
|
|
162,
|
|
162,
|
|
162,
|
|
100,
|
|
101,
|
|
102,
|
|
163,
|
|
163,
|
|
163,
|
|
106,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
-1,
|
|
163,
|
|
117,
|
|
118,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
159,
|
|
163,
|
|
161,
|
|
162,
|
|
127,
|
|
128,
|
|
129,
|
|
130,
|
|
131,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
137,
|
|
163,
|
|
139,
|
|
140,
|
|
141,
|
|
142,
|
|
143,
|
|
144,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
151,
|
|
152,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
159,
|
|
164,
|
|
161,
|
|
162,
|
|
164,
|
|
163,
|
|
-1,
|
|
164,
|
|
166,
|
|
167,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
164,
|
|
-1,
|
|
165,
|
|
165,
|
|
-1,
|
|
166
|
|
];
|
|
PHP.Parser.prototype.yybase = [
|
|
0,
|
|
-2,
|
|
154,
|
|
565,
|
|
876,
|
|
948,
|
|
984,
|
|
514,
|
|
53,
|
|
398,
|
|
837,
|
|
307,
|
|
307,
|
|
67,
|
|
307,
|
|
307,
|
|
307,
|
|
653,
|
|
724,
|
|
724,
|
|
732,
|
|
724,
|
|
616,
|
|
673,
|
|
204,
|
|
204,
|
|
204,
|
|
625,
|
|
625,
|
|
625,
|
|
625,
|
|
694,
|
|
694,
|
|
831,
|
|
831,
|
|
863,
|
|
799,
|
|
765,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
936,
|
|
375,
|
|
519,
|
|
369,
|
|
701,
|
|
1017,
|
|
1023,
|
|
1019,
|
|
1024,
|
|
1015,
|
|
1014,
|
|
1018,
|
|
1020,
|
|
1025,
|
|
911,
|
|
912,
|
|
782,
|
|
918,
|
|
919,
|
|
920,
|
|
921,
|
|
1021,
|
|
841,
|
|
1016,
|
|
1022,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
290,
|
|
491,
|
|
44,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
382,
|
|
160,
|
|
160,
|
|
160,
|
|
187,
|
|
684,
|
|
684,
|
|
341,
|
|
203,
|
|
610,
|
|
47,
|
|
985,
|
|
985,
|
|
985,
|
|
985,
|
|
985,
|
|
985,
|
|
985,
|
|
985,
|
|
985,
|
|
985,
|
|
144,
|
|
144,
|
|
7,
|
|
7,
|
|
7,
|
|
7,
|
|
7,
|
|
371,
|
|
-25,
|
|
-25,
|
|
-25,
|
|
-25,
|
|
540,
|
|
385,
|
|
102,
|
|
576,
|
|
358,
|
|
45,
|
|
377,
|
|
460,
|
|
460,
|
|
360,
|
|
231,
|
|
231,
|
|
231,
|
|
231,
|
|
231,
|
|
231,
|
|
-78,
|
|
-78,
|
|
-78,
|
|
-78,
|
|
-78,
|
|
-66,
|
|
319,
|
|
457,
|
|
-94,
|
|
396,
|
|
423,
|
|
586,
|
|
586,
|
|
586,
|
|
586,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
750,
|
|
1029,
|
|
423,
|
|
423,
|
|
423,
|
|
511,
|
|
516,
|
|
516,
|
|
518,
|
|
147,
|
|
147,
|
|
147,
|
|
516,
|
|
583,
|
|
777,
|
|
422,
|
|
583,
|
|
422,
|
|
194,
|
|
92,
|
|
748,
|
|
-40,
|
|
87,
|
|
412,
|
|
748,
|
|
617,
|
|
627,
|
|
198,
|
|
143,
|
|
773,
|
|
658,
|
|
773,
|
|
1013,
|
|
757,
|
|
764,
|
|
717,
|
|
838,
|
|
860,
|
|
1026,
|
|
800,
|
|
908,
|
|
806,
|
|
910,
|
|
219,
|
|
686,
|
|
1012,
|
|
1012,
|
|
1012,
|
|
1012,
|
|
1012,
|
|
1012,
|
|
1012,
|
|
1012,
|
|
1012,
|
|
1012,
|
|
1012,
|
|
855,
|
|
552,
|
|
1013,
|
|
286,
|
|
855,
|
|
855,
|
|
855,
|
|
552,
|
|
552,
|
|
552,
|
|
552,
|
|
552,
|
|
552,
|
|
552,
|
|
552,
|
|
552,
|
|
552,
|
|
679,
|
|
286,
|
|
568,
|
|
626,
|
|
286,
|
|
794,
|
|
552,
|
|
375,
|
|
758,
|
|
375,
|
|
375,
|
|
375,
|
|
375,
|
|
958,
|
|
375,
|
|
375,
|
|
375,
|
|
375,
|
|
375,
|
|
375,
|
|
970,
|
|
769,
|
|
-16,
|
|
375,
|
|
519,
|
|
12,
|
|
12,
|
|
547,
|
|
83,
|
|
12,
|
|
12,
|
|
12,
|
|
12,
|
|
375,
|
|
375,
|
|
375,
|
|
658,
|
|
781,
|
|
713,
|
|
666,
|
|
792,
|
|
448,
|
|
781,
|
|
781,
|
|
781,
|
|
438,
|
|
444,
|
|
193,
|
|
447,
|
|
570,
|
|
523,
|
|
580,
|
|
760,
|
|
760,
|
|
767,
|
|
929,
|
|
929,
|
|
760,
|
|
759,
|
|
760,
|
|
767,
|
|
934,
|
|
760,
|
|
929,
|
|
805,
|
|
359,
|
|
648,
|
|
577,
|
|
611,
|
|
656,
|
|
929,
|
|
478,
|
|
760,
|
|
760,
|
|
760,
|
|
760,
|
|
665,
|
|
760,
|
|
467,
|
|
433,
|
|
760,
|
|
760,
|
|
785,
|
|
774,
|
|
789,
|
|
60,
|
|
929,
|
|
929,
|
|
929,
|
|
789,
|
|
596,
|
|
751,
|
|
751,
|
|
751,
|
|
811,
|
|
812,
|
|
746,
|
|
771,
|
|
567,
|
|
498,
|
|
677,
|
|
348,
|
|
779,
|
|
771,
|
|
771,
|
|
760,
|
|
640,
|
|
746,
|
|
771,
|
|
746,
|
|
771,
|
|
747,
|
|
771,
|
|
771,
|
|
771,
|
|
746,
|
|
771,
|
|
759,
|
|
585,
|
|
771,
|
|
734,
|
|
668,
|
|
224,
|
|
771,
|
|
6,
|
|
935,
|
|
937,
|
|
354,
|
|
940,
|
|
932,
|
|
941,
|
|
979,
|
|
942,
|
|
943,
|
|
851,
|
|
956,
|
|
933,
|
|
945,
|
|
931,
|
|
930,
|
|
780,
|
|
703,
|
|
720,
|
|
790,
|
|
729,
|
|
928,
|
|
768,
|
|
768,
|
|
768,
|
|
925,
|
|
768,
|
|
768,
|
|
768,
|
|
768,
|
|
768,
|
|
768,
|
|
768,
|
|
768,
|
|
703,
|
|
788,
|
|
804,
|
|
733,
|
|
783,
|
|
960,
|
|
722,
|
|
726,
|
|
725,
|
|
868,
|
|
1027,
|
|
1028,
|
|
737,
|
|
739,
|
|
958,
|
|
1006,
|
|
953,
|
|
803,
|
|
730,
|
|
992,
|
|
967,
|
|
866,
|
|
848,
|
|
968,
|
|
969,
|
|
993,
|
|
1007,
|
|
1008,
|
|
871,
|
|
761,
|
|
874,
|
|
880,
|
|
797,
|
|
971,
|
|
852,
|
|
768,
|
|
935,
|
|
943,
|
|
933,
|
|
945,
|
|
931,
|
|
930,
|
|
763,
|
|
762,
|
|
753,
|
|
755,
|
|
749,
|
|
745,
|
|
736,
|
|
738,
|
|
770,
|
|
1009,
|
|
924,
|
|
835,
|
|
830,
|
|
970,
|
|
926,
|
|
703,
|
|
839,
|
|
986,
|
|
847,
|
|
994,
|
|
995,
|
|
850,
|
|
801,
|
|
772,
|
|
840,
|
|
881,
|
|
972,
|
|
975,
|
|
976,
|
|
853,
|
|
1010,
|
|
810,
|
|
989,
|
|
795,
|
|
996,
|
|
802,
|
|
882,
|
|
997,
|
|
998,
|
|
999,
|
|
1000,
|
|
885,
|
|
854,
|
|
856,
|
|
857,
|
|
815,
|
|
754,
|
|
980,
|
|
786,
|
|
891,
|
|
335,
|
|
787,
|
|
796,
|
|
978,
|
|
363,
|
|
957,
|
|
858,
|
|
894,
|
|
895,
|
|
1001,
|
|
1002,
|
|
1003,
|
|
896,
|
|
954,
|
|
816,
|
|
990,
|
|
752,
|
|
991,
|
|
983,
|
|
817,
|
|
818,
|
|
485,
|
|
784,
|
|
778,
|
|
541,
|
|
676,
|
|
897,
|
|
899,
|
|
900,
|
|
955,
|
|
775,
|
|
766,
|
|
821,
|
|
822,
|
|
1011,
|
|
901,
|
|
697,
|
|
824,
|
|
740,
|
|
902,
|
|
1005,
|
|
742,
|
|
744,
|
|
756,
|
|
859,
|
|
793,
|
|
743,
|
|
798,
|
|
977,
|
|
776,
|
|
827,
|
|
907,
|
|
829,
|
|
832,
|
|
833,
|
|
1004,
|
|
836,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
307,
|
|
307,
|
|
307,
|
|
307,
|
|
0,
|
|
0,
|
|
307,
|
|
0,
|
|
0,
|
|
0,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
458,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
423,
|
|
423,
|
|
291,
|
|
291,
|
|
0,
|
|
291,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
291,
|
|
805,
|
|
147,
|
|
147,
|
|
147,
|
|
147,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
-88,
|
|
-88,
|
|
147,
|
|
147,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
423,
|
|
0,
|
|
0,
|
|
0,
|
|
286,
|
|
422,
|
|
0,
|
|
759,
|
|
759,
|
|
759,
|
|
759,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
422,
|
|
422,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
286,
|
|
422,
|
|
0,
|
|
286,
|
|
0,
|
|
759,
|
|
759,
|
|
423,
|
|
805,
|
|
805,
|
|
314,
|
|
423,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
286,
|
|
759,
|
|
286,
|
|
552,
|
|
422,
|
|
552,
|
|
552,
|
|
12,
|
|
375,
|
|
314,
|
|
608,
|
|
608,
|
|
608,
|
|
608,
|
|
0,
|
|
658,
|
|
805,
|
|
805,
|
|
805,
|
|
805,
|
|
805,
|
|
805,
|
|
805,
|
|
805,
|
|
805,
|
|
805,
|
|
805,
|
|
759,
|
|
0,
|
|
805,
|
|
0,
|
|
759,
|
|
759,
|
|
759,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
759,
|
|
0,
|
|
0,
|
|
929,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
760,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
760,
|
|
934,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
759,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
768,
|
|
801,
|
|
0,
|
|
801,
|
|
0,
|
|
768,
|
|
768,
|
|
768
|
|
];
|
|
PHP.Parser.prototype.yydefault = [
|
|
3,
|
|
32767,
|
|
103,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
101,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
578,
|
|
578,
|
|
578,
|
|
578,
|
|
32767,
|
|
32767,
|
|
246,
|
|
103,
|
|
32767,
|
|
32767,
|
|
454,
|
|
372,
|
|
372,
|
|
372,
|
|
32767,
|
|
32767,
|
|
522,
|
|
522,
|
|
522,
|
|
522,
|
|
522,
|
|
522,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
454,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
101,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
37,
|
|
7,
|
|
8,
|
|
10,
|
|
11,
|
|
50,
|
|
17,
|
|
310,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
103,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
571,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
458,
|
|
437,
|
|
438,
|
|
440,
|
|
441,
|
|
371,
|
|
523,
|
|
577,
|
|
313,
|
|
574,
|
|
370,
|
|
146,
|
|
325,
|
|
315,
|
|
234,
|
|
316,
|
|
250,
|
|
459,
|
|
251,
|
|
460,
|
|
463,
|
|
464,
|
|
211,
|
|
279,
|
|
367,
|
|
150,
|
|
401,
|
|
455,
|
|
403,
|
|
453,
|
|
457,
|
|
402,
|
|
377,
|
|
382,
|
|
383,
|
|
384,
|
|
385,
|
|
386,
|
|
387,
|
|
388,
|
|
389,
|
|
390,
|
|
391,
|
|
392,
|
|
393,
|
|
394,
|
|
375,
|
|
376,
|
|
456,
|
|
434,
|
|
433,
|
|
432,
|
|
399,
|
|
32767,
|
|
32767,
|
|
400,
|
|
404,
|
|
374,
|
|
407,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
103,
|
|
32767,
|
|
405,
|
|
406,
|
|
423,
|
|
424,
|
|
421,
|
|
422,
|
|
425,
|
|
32767,
|
|
426,
|
|
427,
|
|
428,
|
|
429,
|
|
32767,
|
|
32767,
|
|
302,
|
|
32767,
|
|
32767,
|
|
351,
|
|
349,
|
|
414,
|
|
415,
|
|
302,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
516,
|
|
431,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
103,
|
|
32767,
|
|
101,
|
|
518,
|
|
396,
|
|
398,
|
|
486,
|
|
409,
|
|
410,
|
|
408,
|
|
378,
|
|
32767,
|
|
493,
|
|
32767,
|
|
103,
|
|
495,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
112,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
517,
|
|
32767,
|
|
524,
|
|
524,
|
|
32767,
|
|
479,
|
|
101,
|
|
194,
|
|
32767,
|
|
194,
|
|
194,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
585,
|
|
479,
|
|
111,
|
|
111,
|
|
111,
|
|
111,
|
|
111,
|
|
111,
|
|
111,
|
|
111,
|
|
111,
|
|
111,
|
|
111,
|
|
32767,
|
|
194,
|
|
111,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
101,
|
|
194,
|
|
194,
|
|
194,
|
|
194,
|
|
194,
|
|
194,
|
|
194,
|
|
194,
|
|
194,
|
|
194,
|
|
189,
|
|
32767,
|
|
260,
|
|
262,
|
|
103,
|
|
539,
|
|
194,
|
|
32767,
|
|
498,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
491,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
479,
|
|
419,
|
|
139,
|
|
32767,
|
|
139,
|
|
524,
|
|
411,
|
|
412,
|
|
413,
|
|
481,
|
|
524,
|
|
524,
|
|
524,
|
|
298,
|
|
281,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
496,
|
|
496,
|
|
101,
|
|
101,
|
|
101,
|
|
101,
|
|
491,
|
|
32767,
|
|
32767,
|
|
112,
|
|
100,
|
|
100,
|
|
100,
|
|
100,
|
|
100,
|
|
104,
|
|
102,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
100,
|
|
32767,
|
|
102,
|
|
102,
|
|
32767,
|
|
32767,
|
|
217,
|
|
208,
|
|
215,
|
|
102,
|
|
32767,
|
|
543,
|
|
544,
|
|
215,
|
|
102,
|
|
219,
|
|
219,
|
|
219,
|
|
239,
|
|
239,
|
|
470,
|
|
304,
|
|
102,
|
|
100,
|
|
102,
|
|
102,
|
|
196,
|
|
304,
|
|
304,
|
|
32767,
|
|
102,
|
|
470,
|
|
304,
|
|
470,
|
|
304,
|
|
198,
|
|
304,
|
|
304,
|
|
304,
|
|
470,
|
|
304,
|
|
32767,
|
|
102,
|
|
304,
|
|
210,
|
|
100,
|
|
100,
|
|
304,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
481,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
511,
|
|
32767,
|
|
528,
|
|
541,
|
|
417,
|
|
418,
|
|
420,
|
|
526,
|
|
442,
|
|
443,
|
|
444,
|
|
445,
|
|
446,
|
|
447,
|
|
448,
|
|
450,
|
|
573,
|
|
32767,
|
|
485,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
324,
|
|
583,
|
|
32767,
|
|
583,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
584,
|
|
32767,
|
|
524,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
416,
|
|
9,
|
|
76,
|
|
43,
|
|
44,
|
|
52,
|
|
58,
|
|
502,
|
|
503,
|
|
504,
|
|
505,
|
|
499,
|
|
500,
|
|
506,
|
|
501,
|
|
32767,
|
|
32767,
|
|
507,
|
|
549,
|
|
32767,
|
|
32767,
|
|
525,
|
|
576,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
139,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
511,
|
|
32767,
|
|
137,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
524,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
300,
|
|
301,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
524,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
283,
|
|
284,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
278,
|
|
32767,
|
|
32767,
|
|
366,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
345,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
32767,
|
|
152,
|
|
152,
|
|
3,
|
|
3,
|
|
327,
|
|
152,
|
|
152,
|
|
152,
|
|
327,
|
|
152,
|
|
327,
|
|
327,
|
|
327,
|
|
152,
|
|
152,
|
|
152,
|
|
152,
|
|
152,
|
|
152,
|
|
272,
|
|
184,
|
|
254,
|
|
257,
|
|
239,
|
|
239,
|
|
152,
|
|
337,
|
|
152
|
|
];
|
|
PHP.Parser.prototype.yygoto = [
|
|
194,
|
|
194,
|
|
670,
|
|
422,
|
|
643,
|
|
463,
|
|
1264,
|
|
1265,
|
|
1022,
|
|
416,
|
|
308,
|
|
309,
|
|
329,
|
|
563,
|
|
314,
|
|
421,
|
|
330,
|
|
423,
|
|
622,
|
|
801,
|
|
678,
|
|
637,
|
|
586,
|
|
651,
|
|
652,
|
|
653,
|
|
165,
|
|
165,
|
|
165,
|
|
165,
|
|
218,
|
|
195,
|
|
191,
|
|
191,
|
|
175,
|
|
177,
|
|
213,
|
|
191,
|
|
191,
|
|
191,
|
|
191,
|
|
191,
|
|
192,
|
|
192,
|
|
192,
|
|
192,
|
|
192,
|
|
192,
|
|
186,
|
|
187,
|
|
188,
|
|
189,
|
|
190,
|
|
215,
|
|
213,
|
|
216,
|
|
521,
|
|
522,
|
|
412,
|
|
523,
|
|
525,
|
|
526,
|
|
527,
|
|
528,
|
|
529,
|
|
530,
|
|
531,
|
|
532,
|
|
1091,
|
|
166,
|
|
167,
|
|
168,
|
|
193,
|
|
169,
|
|
170,
|
|
171,
|
|
164,
|
|
172,
|
|
173,
|
|
174,
|
|
176,
|
|
212,
|
|
214,
|
|
217,
|
|
235,
|
|
238,
|
|
241,
|
|
242,
|
|
244,
|
|
255,
|
|
256,
|
|
257,
|
|
258,
|
|
259,
|
|
260,
|
|
261,
|
|
263,
|
|
264,
|
|
265,
|
|
266,
|
|
274,
|
|
275,
|
|
311,
|
|
312,
|
|
313,
|
|
417,
|
|
418,
|
|
419,
|
|
568,
|
|
219,
|
|
220,
|
|
221,
|
|
222,
|
|
223,
|
|
224,
|
|
225,
|
|
226,
|
|
227,
|
|
228,
|
|
229,
|
|
230,
|
|
231,
|
|
232,
|
|
233,
|
|
178,
|
|
234,
|
|
179,
|
|
196,
|
|
197,
|
|
198,
|
|
236,
|
|
186,
|
|
187,
|
|
188,
|
|
189,
|
|
190,
|
|
215,
|
|
1091,
|
|
199,
|
|
180,
|
|
181,
|
|
182,
|
|
200,
|
|
196,
|
|
183,
|
|
237,
|
|
201,
|
|
199,
|
|
163,
|
|
202,
|
|
203,
|
|
184,
|
|
204,
|
|
205,
|
|
206,
|
|
185,
|
|
207,
|
|
208,
|
|
209,
|
|
210,
|
|
211,
|
|
323,
|
|
323,
|
|
323,
|
|
323,
|
|
827,
|
|
608,
|
|
608,
|
|
824,
|
|
547,
|
|
538,
|
|
342,
|
|
1221,
|
|
1221,
|
|
1221,
|
|
1221,
|
|
1221,
|
|
1221,
|
|
1221,
|
|
1221,
|
|
1221,
|
|
1221,
|
|
1239,
|
|
1239,
|
|
288,
|
|
288,
|
|
288,
|
|
288,
|
|
1239,
|
|
1239,
|
|
1239,
|
|
1239,
|
|
1239,
|
|
1239,
|
|
1239,
|
|
1239,
|
|
1239,
|
|
1239,
|
|
388,
|
|
538,
|
|
547,
|
|
556,
|
|
557,
|
|
395,
|
|
566,
|
|
588,
|
|
602,
|
|
603,
|
|
832,
|
|
825,
|
|
880,
|
|
875,
|
|
876,
|
|
889,
|
|
15,
|
|
833,
|
|
877,
|
|
830,
|
|
878,
|
|
879,
|
|
831,
|
|
799,
|
|
251,
|
|
251,
|
|
883,
|
|
919,
|
|
992,
|
|
1000,
|
|
1004,
|
|
1001,
|
|
1005,
|
|
1237,
|
|
1237,
|
|
938,
|
|
1043,
|
|
1039,
|
|
1040,
|
|
1237,
|
|
1237,
|
|
1237,
|
|
1237,
|
|
1237,
|
|
1237,
|
|
1237,
|
|
1237,
|
|
1237,
|
|
1237,
|
|
858,
|
|
248,
|
|
248,
|
|
248,
|
|
248,
|
|
250,
|
|
252,
|
|
533,
|
|
533,
|
|
533,
|
|
533,
|
|
487,
|
|
590,
|
|
488,
|
|
1190,
|
|
1190,
|
|
997,
|
|
1190,
|
|
997,
|
|
494,
|
|
1290,
|
|
1290,
|
|
560,
|
|
997,
|
|
997,
|
|
997,
|
|
997,
|
|
997,
|
|
997,
|
|
997,
|
|
997,
|
|
997,
|
|
997,
|
|
997,
|
|
997,
|
|
1261,
|
|
1261,
|
|
1290,
|
|
1261,
|
|
340,
|
|
1190,
|
|
930,
|
|
402,
|
|
677,
|
|
1279,
|
|
1190,
|
|
1190,
|
|
1190,
|
|
1190,
|
|
959,
|
|
345,
|
|
1190,
|
|
1190,
|
|
1190,
|
|
1271,
|
|
1271,
|
|
1271,
|
|
1271,
|
|
606,
|
|
640,
|
|
345,
|
|
345,
|
|
1273,
|
|
1273,
|
|
1273,
|
|
1273,
|
|
820,
|
|
820,
|
|
805,
|
|
896,
|
|
884,
|
|
840,
|
|
885,
|
|
897,
|
|
345,
|
|
345,
|
|
5,
|
|
345,
|
|
6,
|
|
1306,
|
|
384,
|
|
535,
|
|
535,
|
|
559,
|
|
535,
|
|
415,
|
|
852,
|
|
597,
|
|
1257,
|
|
839,
|
|
540,
|
|
524,
|
|
524,
|
|
345,
|
|
1289,
|
|
1289,
|
|
642,
|
|
524,
|
|
524,
|
|
524,
|
|
524,
|
|
524,
|
|
524,
|
|
524,
|
|
524,
|
|
524,
|
|
524,
|
|
445,
|
|
805,
|
|
1140,
|
|
805,
|
|
1289,
|
|
932,
|
|
932,
|
|
932,
|
|
932,
|
|
1063,
|
|
1064,
|
|
445,
|
|
926,
|
|
933,
|
|
386,
|
|
390,
|
|
548,
|
|
587,
|
|
591,
|
|
1030,
|
|
1292,
|
|
331,
|
|
554,
|
|
1259,
|
|
1259,
|
|
1030,
|
|
704,
|
|
621,
|
|
623,
|
|
823,
|
|
641,
|
|
1250,
|
|
319,
|
|
303,
|
|
660,
|
|
664,
|
|
973,
|
|
668,
|
|
676,
|
|
969,
|
|
429,
|
|
553,
|
|
962,
|
|
936,
|
|
936,
|
|
934,
|
|
936,
|
|
703,
|
|
601,
|
|
537,
|
|
971,
|
|
966,
|
|
343,
|
|
344,
|
|
663,
|
|
817,
|
|
595,
|
|
609,
|
|
612,
|
|
613,
|
|
614,
|
|
615,
|
|
634,
|
|
635,
|
|
636,
|
|
680,
|
|
439,
|
|
1186,
|
|
845,
|
|
454,
|
|
454,
|
|
439,
|
|
439,
|
|
1266,
|
|
1267,
|
|
820,
|
|
901,
|
|
1079,
|
|
454,
|
|
394,
|
|
539,
|
|
551,
|
|
1183,
|
|
605,
|
|
540,
|
|
539,
|
|
842,
|
|
551,
|
|
978,
|
|
272,
|
|
387,
|
|
618,
|
|
619,
|
|
981,
|
|
536,
|
|
536,
|
|
844,
|
|
707,
|
|
646,
|
|
957,
|
|
567,
|
|
457,
|
|
458,
|
|
459,
|
|
838,
|
|
850,
|
|
254,
|
|
254,
|
|
1297,
|
|
1298,
|
|
400,
|
|
401,
|
|
976,
|
|
976,
|
|
464,
|
|
649,
|
|
1182,
|
|
650,
|
|
1028,
|
|
404,
|
|
405,
|
|
406,
|
|
1187,
|
|
661,
|
|
424,
|
|
1032,
|
|
407,
|
|
564,
|
|
600,
|
|
815,
|
|
338,
|
|
424,
|
|
854,
|
|
848,
|
|
853,
|
|
841,
|
|
1027,
|
|
1031,
|
|
1009,
|
|
1002,
|
|
1006,
|
|
1003,
|
|
1007,
|
|
1185,
|
|
941,
|
|
1188,
|
|
1247,
|
|
1248,
|
|
943,
|
|
0,
|
|
1074,
|
|
439,
|
|
439,
|
|
439,
|
|
439,
|
|
439,
|
|
439,
|
|
439,
|
|
439,
|
|
439,
|
|
439,
|
|
439,
|
|
0,
|
|
468,
|
|
439,
|
|
585,
|
|
1056,
|
|
931,
|
|
681,
|
|
667,
|
|
667,
|
|
0,
|
|
495,
|
|
673,
|
|
1054,
|
|
1171,
|
|
912,
|
|
0,
|
|
0,
|
|
1172,
|
|
1175,
|
|
913,
|
|
1176,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1072,
|
|
857
|
|
];
|
|
PHP.Parser.prototype.yygcheck = [
|
|
42,
|
|
42,
|
|
72,
|
|
65,
|
|
65,
|
|
166,
|
|
166,
|
|
166,
|
|
119,
|
|
65,
|
|
65,
|
|
65,
|
|
65,
|
|
65,
|
|
65,
|
|
65,
|
|
65,
|
|
65,
|
|
65,
|
|
7,
|
|
9,
|
|
84,
|
|
122,
|
|
84,
|
|
84,
|
|
84,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
23,
|
|
23,
|
|
23,
|
|
23,
|
|
15,
|
|
104,
|
|
104,
|
|
26,
|
|
75,
|
|
75,
|
|
93,
|
|
104,
|
|
104,
|
|
104,
|
|
104,
|
|
104,
|
|
104,
|
|
104,
|
|
104,
|
|
104,
|
|
104,
|
|
160,
|
|
160,
|
|
24,
|
|
24,
|
|
24,
|
|
24,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
75,
|
|
75,
|
|
75,
|
|
75,
|
|
75,
|
|
75,
|
|
75,
|
|
75,
|
|
75,
|
|
75,
|
|
15,
|
|
27,
|
|
15,
|
|
15,
|
|
15,
|
|
15,
|
|
75,
|
|
15,
|
|
15,
|
|
15,
|
|
15,
|
|
15,
|
|
15,
|
|
6,
|
|
5,
|
|
5,
|
|
15,
|
|
87,
|
|
87,
|
|
87,
|
|
87,
|
|
87,
|
|
87,
|
|
161,
|
|
161,
|
|
49,
|
|
15,
|
|
15,
|
|
15,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
161,
|
|
45,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
103,
|
|
103,
|
|
103,
|
|
103,
|
|
147,
|
|
103,
|
|
147,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
147,
|
|
173,
|
|
173,
|
|
162,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
122,
|
|
122,
|
|
173,
|
|
122,
|
|
169,
|
|
72,
|
|
89,
|
|
89,
|
|
89,
|
|
171,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
99,
|
|
14,
|
|
72,
|
|
72,
|
|
72,
|
|
9,
|
|
9,
|
|
9,
|
|
9,
|
|
55,
|
|
55,
|
|
14,
|
|
14,
|
|
122,
|
|
122,
|
|
122,
|
|
122,
|
|
22,
|
|
22,
|
|
12,
|
|
72,
|
|
64,
|
|
35,
|
|
64,
|
|
72,
|
|
14,
|
|
14,
|
|
46,
|
|
14,
|
|
46,
|
|
14,
|
|
61,
|
|
19,
|
|
19,
|
|
100,
|
|
19,
|
|
13,
|
|
35,
|
|
13,
|
|
122,
|
|
35,
|
|
14,
|
|
163,
|
|
163,
|
|
14,
|
|
172,
|
|
172,
|
|
63,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
19,
|
|
12,
|
|
143,
|
|
12,
|
|
172,
|
|
19,
|
|
19,
|
|
19,
|
|
19,
|
|
136,
|
|
136,
|
|
19,
|
|
19,
|
|
19,
|
|
58,
|
|
58,
|
|
58,
|
|
58,
|
|
58,
|
|
122,
|
|
172,
|
|
29,
|
|
48,
|
|
122,
|
|
122,
|
|
122,
|
|
48,
|
|
48,
|
|
48,
|
|
25,
|
|
48,
|
|
14,
|
|
159,
|
|
159,
|
|
48,
|
|
48,
|
|
48,
|
|
48,
|
|
48,
|
|
48,
|
|
109,
|
|
9,
|
|
25,
|
|
25,
|
|
25,
|
|
25,
|
|
25,
|
|
25,
|
|
9,
|
|
25,
|
|
25,
|
|
25,
|
|
93,
|
|
93,
|
|
14,
|
|
18,
|
|
79,
|
|
79,
|
|
79,
|
|
79,
|
|
79,
|
|
79,
|
|
79,
|
|
79,
|
|
79,
|
|
79,
|
|
23,
|
|
20,
|
|
39,
|
|
141,
|
|
141,
|
|
23,
|
|
23,
|
|
168,
|
|
168,
|
|
22,
|
|
17,
|
|
17,
|
|
141,
|
|
28,
|
|
9,
|
|
9,
|
|
152,
|
|
17,
|
|
14,
|
|
9,
|
|
37,
|
|
9,
|
|
17,
|
|
24,
|
|
9,
|
|
83,
|
|
83,
|
|
106,
|
|
24,
|
|
24,
|
|
17,
|
|
95,
|
|
17,
|
|
17,
|
|
9,
|
|
9,
|
|
9,
|
|
9,
|
|
17,
|
|
9,
|
|
5,
|
|
5,
|
|
9,
|
|
9,
|
|
80,
|
|
80,
|
|
103,
|
|
103,
|
|
149,
|
|
80,
|
|
17,
|
|
80,
|
|
121,
|
|
80,
|
|
80,
|
|
80,
|
|
20,
|
|
80,
|
|
113,
|
|
124,
|
|
80,
|
|
2,
|
|
2,
|
|
20,
|
|
80,
|
|
113,
|
|
41,
|
|
9,
|
|
16,
|
|
16,
|
|
16,
|
|
16,
|
|
113,
|
|
113,
|
|
113,
|
|
113,
|
|
113,
|
|
14,
|
|
16,
|
|
20,
|
|
20,
|
|
20,
|
|
92,
|
|
-1,
|
|
139,
|
|
23,
|
|
23,
|
|
23,
|
|
23,
|
|
23,
|
|
23,
|
|
23,
|
|
23,
|
|
23,
|
|
23,
|
|
23,
|
|
-1,
|
|
82,
|
|
23,
|
|
8,
|
|
8,
|
|
16,
|
|
8,
|
|
8,
|
|
8,
|
|
-1,
|
|
8,
|
|
8,
|
|
8,
|
|
78,
|
|
78,
|
|
-1,
|
|
-1,
|
|
78,
|
|
78,
|
|
78,
|
|
78,
|
|
-1,
|
|
-1,
|
|
-1,
|
|
-1,
|
|
-1,
|
|
-1,
|
|
16,
|
|
16
|
|
];
|
|
PHP.Parser.prototype.yygbase = [
|
|
0,
|
|
0,
|
|
-203,
|
|
0,
|
|
0,
|
|
221,
|
|
208,
|
|
10,
|
|
512,
|
|
7,
|
|
0,
|
|
0,
|
|
24,
|
|
1,
|
|
5,
|
|
-174,
|
|
47,
|
|
-23,
|
|
105,
|
|
61,
|
|
38,
|
|
0,
|
|
-10,
|
|
158,
|
|
181,
|
|
379,
|
|
164,
|
|
205,
|
|
102,
|
|
84,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
-43,
|
|
0,
|
|
107,
|
|
0,
|
|
104,
|
|
0,
|
|
54,
|
|
-1,
|
|
0,
|
|
0,
|
|
235,
|
|
-384,
|
|
0,
|
|
-307,
|
|
210,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
266,
|
|
0,
|
|
0,
|
|
324,
|
|
0,
|
|
0,
|
|
286,
|
|
0,
|
|
103,
|
|
298,
|
|
-236,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
-6,
|
|
0,
|
|
0,
|
|
-167,
|
|
0,
|
|
0,
|
|
129,
|
|
62,
|
|
-14,
|
|
0,
|
|
53,
|
|
-22,
|
|
-669,
|
|
0,
|
|
0,
|
|
-52,
|
|
0,
|
|
-11,
|
|
0,
|
|
0,
|
|
68,
|
|
-299,
|
|
0,
|
|
52,
|
|
0,
|
|
0,
|
|
0,
|
|
262,
|
|
288,
|
|
0,
|
|
0,
|
|
227,
|
|
-73,
|
|
0,
|
|
87,
|
|
0,
|
|
0,
|
|
118,
|
|
0,
|
|
0,
|
|
0,
|
|
209,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
6,
|
|
0,
|
|
108,
|
|
15,
|
|
0,
|
|
46,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
91,
|
|
0,
|
|
0,
|
|
69,
|
|
0,
|
|
390,
|
|
0,
|
|
86,
|
|
0,
|
|
0,
|
|
0,
|
|
-224,
|
|
0,
|
|
37,
|
|
0,
|
|
0,
|
|
77,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
70,
|
|
-57,
|
|
-8,
|
|
241,
|
|
99,
|
|
0,
|
|
0,
|
|
-290,
|
|
0,
|
|
65,
|
|
257,
|
|
0,
|
|
261,
|
|
39,
|
|
-35,
|
|
0,
|
|
0
|
|
];
|
|
PHP.Parser.prototype.yygdefault = [
|
|
-32768,
|
|
499,
|
|
711,
|
|
4,
|
|
712,
|
|
905,
|
|
788,
|
|
797,
|
|
583,
|
|
515,
|
|
679,
|
|
339,
|
|
610,
|
|
413,
|
|
1255,
|
|
882,
|
|
1078,
|
|
565,
|
|
816,
|
|
1199,
|
|
1207,
|
|
446,
|
|
819,
|
|
324,
|
|
701,
|
|
864,
|
|
865,
|
|
866,
|
|
391,
|
|
376,
|
|
382,
|
|
389,
|
|
632,
|
|
611,
|
|
481,
|
|
851,
|
|
442,
|
|
843,
|
|
473,
|
|
846,
|
|
441,
|
|
855,
|
|
162,
|
|
410,
|
|
497,
|
|
859,
|
|
3,
|
|
861,
|
|
542,
|
|
892,
|
|
377,
|
|
869,
|
|
378,
|
|
656,
|
|
871,
|
|
550,
|
|
873,
|
|
874,
|
|
385,
|
|
392,
|
|
393,
|
|
1083,
|
|
558,
|
|
607,
|
|
886,
|
|
243,
|
|
552,
|
|
887,
|
|
375,
|
|
888,
|
|
895,
|
|
380,
|
|
383,
|
|
665,
|
|
453,
|
|
492,
|
|
486,
|
|
403,
|
|
1058,
|
|
594,
|
|
629,
|
|
450,
|
|
467,
|
|
617,
|
|
616,
|
|
604,
|
|
466,
|
|
425,
|
|
408,
|
|
928,
|
|
474,
|
|
451,
|
|
942,
|
|
341,
|
|
950,
|
|
709,
|
|
1090,
|
|
624,
|
|
476,
|
|
958,
|
|
625,
|
|
965,
|
|
968,
|
|
516,
|
|
517,
|
|
465,
|
|
980,
|
|
269,
|
|
983,
|
|
477,
|
|
1015,
|
|
647,
|
|
648,
|
|
995,
|
|
626,
|
|
627,
|
|
1013,
|
|
460,
|
|
584,
|
|
1021,
|
|
443,
|
|
1029,
|
|
1243,
|
|
444,
|
|
1033,
|
|
262,
|
|
1036,
|
|
276,
|
|
409,
|
|
426,
|
|
1041,
|
|
1042,
|
|
8,
|
|
1048,
|
|
671,
|
|
672,
|
|
10,
|
|
273,
|
|
496,
|
|
1073,
|
|
666,
|
|
440,
|
|
1089,
|
|
430,
|
|
1159,
|
|
1161,
|
|
544,
|
|
478,
|
|
1179,
|
|
1178,
|
|
659,
|
|
493,
|
|
1184,
|
|
1246,
|
|
438,
|
|
518,
|
|
461,
|
|
310,
|
|
519,
|
|
302,
|
|
327,
|
|
307,
|
|
534,
|
|
289,
|
|
328,
|
|
520,
|
|
462,
|
|
1252,
|
|
1260,
|
|
325,
|
|
30,
|
|
1280,
|
|
1291,
|
|
335,
|
|
562,
|
|
599
|
|
];
|
|
PHP.Parser.prototype.yylhs = [
|
|
0,
|
|
1,
|
|
3,
|
|
3,
|
|
2,
|
|
5,
|
|
5,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
6,
|
|
7,
|
|
7,
|
|
7,
|
|
7,
|
|
7,
|
|
7,
|
|
7,
|
|
7,
|
|
8,
|
|
8,
|
|
9,
|
|
10,
|
|
11,
|
|
11,
|
|
11,
|
|
12,
|
|
12,
|
|
13,
|
|
13,
|
|
14,
|
|
15,
|
|
15,
|
|
16,
|
|
16,
|
|
17,
|
|
17,
|
|
18,
|
|
18,
|
|
21,
|
|
21,
|
|
22,
|
|
23,
|
|
23,
|
|
24,
|
|
24,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
29,
|
|
29,
|
|
30,
|
|
30,
|
|
32,
|
|
34,
|
|
34,
|
|
28,
|
|
36,
|
|
36,
|
|
33,
|
|
38,
|
|
38,
|
|
35,
|
|
35,
|
|
37,
|
|
37,
|
|
39,
|
|
39,
|
|
31,
|
|
40,
|
|
40,
|
|
41,
|
|
43,
|
|
44,
|
|
44,
|
|
45,
|
|
46,
|
|
46,
|
|
48,
|
|
47,
|
|
47,
|
|
47,
|
|
47,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
49,
|
|
25,
|
|
25,
|
|
68,
|
|
68,
|
|
71,
|
|
71,
|
|
70,
|
|
69,
|
|
69,
|
|
62,
|
|
74,
|
|
74,
|
|
75,
|
|
75,
|
|
76,
|
|
76,
|
|
77,
|
|
77,
|
|
78,
|
|
78,
|
|
26,
|
|
26,
|
|
27,
|
|
27,
|
|
27,
|
|
27,
|
|
86,
|
|
86,
|
|
88,
|
|
88,
|
|
81,
|
|
81,
|
|
81,
|
|
82,
|
|
82,
|
|
85,
|
|
85,
|
|
83,
|
|
83,
|
|
89,
|
|
90,
|
|
90,
|
|
56,
|
|
56,
|
|
64,
|
|
64,
|
|
67,
|
|
67,
|
|
67,
|
|
66,
|
|
91,
|
|
91,
|
|
92,
|
|
57,
|
|
57,
|
|
57,
|
|
57,
|
|
93,
|
|
93,
|
|
94,
|
|
94,
|
|
95,
|
|
95,
|
|
96,
|
|
97,
|
|
97,
|
|
98,
|
|
98,
|
|
99,
|
|
99,
|
|
54,
|
|
54,
|
|
50,
|
|
50,
|
|
101,
|
|
52,
|
|
52,
|
|
102,
|
|
51,
|
|
51,
|
|
53,
|
|
53,
|
|
63,
|
|
63,
|
|
63,
|
|
63,
|
|
79,
|
|
79,
|
|
105,
|
|
105,
|
|
107,
|
|
107,
|
|
108,
|
|
108,
|
|
108,
|
|
108,
|
|
106,
|
|
106,
|
|
106,
|
|
110,
|
|
110,
|
|
110,
|
|
110,
|
|
87,
|
|
87,
|
|
113,
|
|
113,
|
|
113,
|
|
111,
|
|
111,
|
|
114,
|
|
114,
|
|
112,
|
|
112,
|
|
115,
|
|
115,
|
|
116,
|
|
116,
|
|
116,
|
|
116,
|
|
109,
|
|
109,
|
|
80,
|
|
80,
|
|
80,
|
|
20,
|
|
20,
|
|
20,
|
|
118,
|
|
117,
|
|
117,
|
|
119,
|
|
119,
|
|
119,
|
|
119,
|
|
59,
|
|
120,
|
|
120,
|
|
121,
|
|
60,
|
|
123,
|
|
123,
|
|
124,
|
|
124,
|
|
125,
|
|
125,
|
|
84,
|
|
126,
|
|
126,
|
|
126,
|
|
126,
|
|
126,
|
|
126,
|
|
131,
|
|
131,
|
|
132,
|
|
132,
|
|
133,
|
|
133,
|
|
133,
|
|
133,
|
|
133,
|
|
134,
|
|
135,
|
|
135,
|
|
130,
|
|
130,
|
|
127,
|
|
127,
|
|
129,
|
|
129,
|
|
137,
|
|
137,
|
|
136,
|
|
136,
|
|
136,
|
|
136,
|
|
136,
|
|
136,
|
|
136,
|
|
128,
|
|
138,
|
|
138,
|
|
140,
|
|
139,
|
|
139,
|
|
61,
|
|
100,
|
|
141,
|
|
141,
|
|
55,
|
|
55,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
42,
|
|
148,
|
|
142,
|
|
142,
|
|
147,
|
|
147,
|
|
150,
|
|
151,
|
|
151,
|
|
152,
|
|
153,
|
|
153,
|
|
153,
|
|
19,
|
|
19,
|
|
72,
|
|
72,
|
|
72,
|
|
72,
|
|
143,
|
|
143,
|
|
143,
|
|
143,
|
|
155,
|
|
155,
|
|
144,
|
|
144,
|
|
146,
|
|
146,
|
|
146,
|
|
149,
|
|
149,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
160,
|
|
161,
|
|
161,
|
|
104,
|
|
163,
|
|
163,
|
|
163,
|
|
163,
|
|
145,
|
|
145,
|
|
145,
|
|
145,
|
|
145,
|
|
145,
|
|
145,
|
|
145,
|
|
58,
|
|
58,
|
|
158,
|
|
158,
|
|
158,
|
|
158,
|
|
164,
|
|
164,
|
|
154,
|
|
154,
|
|
154,
|
|
165,
|
|
165,
|
|
165,
|
|
165,
|
|
165,
|
|
165,
|
|
73,
|
|
73,
|
|
65,
|
|
65,
|
|
65,
|
|
65,
|
|
122,
|
|
122,
|
|
122,
|
|
122,
|
|
168,
|
|
167,
|
|
157,
|
|
157,
|
|
157,
|
|
157,
|
|
157,
|
|
157,
|
|
157,
|
|
156,
|
|
156,
|
|
156,
|
|
166,
|
|
166,
|
|
166,
|
|
166,
|
|
103,
|
|
162,
|
|
170,
|
|
170,
|
|
169,
|
|
169,
|
|
171,
|
|
171,
|
|
171,
|
|
171,
|
|
171,
|
|
171,
|
|
171,
|
|
171,
|
|
159,
|
|
159,
|
|
159,
|
|
159,
|
|
173,
|
|
174,
|
|
172,
|
|
172,
|
|
172,
|
|
172,
|
|
172,
|
|
172,
|
|
172,
|
|
172,
|
|
175,
|
|
175,
|
|
175,
|
|
175
|
|
];
|
|
PHP.Parser.prototype.yylen = [
|
|
1,
|
|
1,
|
|
2,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
2,
|
|
1,
|
|
3,
|
|
4,
|
|
1,
|
|
2,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
3,
|
|
5,
|
|
4,
|
|
3,
|
|
4,
|
|
2,
|
|
3,
|
|
1,
|
|
1,
|
|
7,
|
|
6,
|
|
2,
|
|
3,
|
|
1,
|
|
2,
|
|
3,
|
|
1,
|
|
2,
|
|
3,
|
|
1,
|
|
1,
|
|
3,
|
|
1,
|
|
3,
|
|
1,
|
|
2,
|
|
2,
|
|
3,
|
|
1,
|
|
3,
|
|
2,
|
|
3,
|
|
1,
|
|
3,
|
|
2,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
3,
|
|
7,
|
|
10,
|
|
5,
|
|
7,
|
|
9,
|
|
5,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
1,
|
|
2,
|
|
5,
|
|
7,
|
|
9,
|
|
6,
|
|
5,
|
|
6,
|
|
3,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
2,
|
|
1,
|
|
3,
|
|
8,
|
|
0,
|
|
4,
|
|
2,
|
|
1,
|
|
3,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
3,
|
|
1,
|
|
8,
|
|
9,
|
|
8,
|
|
7,
|
|
6,
|
|
8,
|
|
0,
|
|
2,
|
|
0,
|
|
2,
|
|
1,
|
|
2,
|
|
2,
|
|
0,
|
|
2,
|
|
0,
|
|
2,
|
|
0,
|
|
2,
|
|
2,
|
|
1,
|
|
3,
|
|
1,
|
|
4,
|
|
1,
|
|
4,
|
|
1,
|
|
1,
|
|
4,
|
|
2,
|
|
1,
|
|
3,
|
|
3,
|
|
3,
|
|
4,
|
|
4,
|
|
5,
|
|
0,
|
|
2,
|
|
4,
|
|
3,
|
|
1,
|
|
1,
|
|
7,
|
|
0,
|
|
2,
|
|
1,
|
|
3,
|
|
3,
|
|
4,
|
|
1,
|
|
4,
|
|
0,
|
|
2,
|
|
5,
|
|
0,
|
|
2,
|
|
6,
|
|
0,
|
|
2,
|
|
0,
|
|
3,
|
|
1,
|
|
2,
|
|
1,
|
|
1,
|
|
2,
|
|
0,
|
|
1,
|
|
3,
|
|
0,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
6,
|
|
8,
|
|
6,
|
|
1,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
1,
|
|
2,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
2,
|
|
2,
|
|
2,
|
|
4,
|
|
3,
|
|
1,
|
|
1,
|
|
3,
|
|
1,
|
|
2,
|
|
2,
|
|
3,
|
|
2,
|
|
3,
|
|
1,
|
|
1,
|
|
2,
|
|
3,
|
|
1,
|
|
1,
|
|
3,
|
|
2,
|
|
0,
|
|
1,
|
|
5,
|
|
5,
|
|
10,
|
|
3,
|
|
5,
|
|
1,
|
|
1,
|
|
3,
|
|
0,
|
|
2,
|
|
4,
|
|
5,
|
|
4,
|
|
4,
|
|
4,
|
|
3,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
2,
|
|
1,
|
|
3,
|
|
1,
|
|
1,
|
|
3,
|
|
2,
|
|
2,
|
|
3,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
3,
|
|
3,
|
|
3,
|
|
4,
|
|
1,
|
|
1,
|
|
2,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
5,
|
|
4,
|
|
3,
|
|
4,
|
|
4,
|
|
2,
|
|
2,
|
|
4,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
1,
|
|
3,
|
|
2,
|
|
1,
|
|
2,
|
|
4,
|
|
2,
|
|
2,
|
|
8,
|
|
9,
|
|
8,
|
|
9,
|
|
9,
|
|
10,
|
|
9,
|
|
10,
|
|
8,
|
|
3,
|
|
2,
|
|
0,
|
|
4,
|
|
2,
|
|
1,
|
|
3,
|
|
2,
|
|
2,
|
|
2,
|
|
4,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
3,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
3,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
3,
|
|
3,
|
|
3,
|
|
4,
|
|
1,
|
|
1,
|
|
3,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
3,
|
|
2,
|
|
3,
|
|
0,
|
|
1,
|
|
1,
|
|
3,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
3,
|
|
1,
|
|
1,
|
|
4,
|
|
4,
|
|
1,
|
|
4,
|
|
4,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
3,
|
|
3,
|
|
1,
|
|
4,
|
|
2,
|
|
2,
|
|
1,
|
|
3,
|
|
1,
|
|
4,
|
|
4,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
1,
|
|
3,
|
|
1,
|
|
1,
|
|
3,
|
|
1,
|
|
1,
|
|
4,
|
|
1,
|
|
1,
|
|
1,
|
|
3,
|
|
1,
|
|
1,
|
|
2,
|
|
1,
|
|
3,
|
|
4,
|
|
3,
|
|
2,
|
|
0,
|
|
2,
|
|
2,
|
|
1,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
4,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
6,
|
|
3,
|
|
1,
|
|
1,
|
|
2,
|
|
1
|
|
];
|
|
exports.j = PHP;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 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] = {
|
|
/******/ // no module.id needed
|
|
/******/ // no module.loaded needed
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // 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 });
|
|
/******/ };
|
|
/******/ })();
|
|
/******/
|
|
/************************************************************************/
|
|
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__, {
|
|
PhpService: () => (/* binding */ PhpService)
|
|
});
|
|
|
|
// EXTERNAL MODULE: ./src/services/base-service.ts
|
|
var base_service = __webpack_require__(2125);
|
|
// EXTERNAL MODULE: ./src/services/php/lib/php.js
|
|
var php = __webpack_require__(4849);
|
|
// 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/php/php-service.ts
|
|
function php_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 PhpService extends base_service.BaseService {
|
|
async doValidation(document) {
|
|
let value = this.getDocumentValue(document.uri);
|
|
if (!value) return [];
|
|
if (this.getOption(document.uri, "inline")) {
|
|
value = "<?" + value + "?>";
|
|
}
|
|
var tokens = php/* PHP */.j.Lexer(value, {
|
|
short_open_tag: 1
|
|
});
|
|
let errors = [];
|
|
try {
|
|
new php/* PHP */.j.Parser(tokens);
|
|
} catch (e) {
|
|
errors.push({
|
|
range: {
|
|
start: {
|
|
line: e.line - 1,
|
|
character: 0
|
|
},
|
|
end: {
|
|
line: e.line - 1,
|
|
character: 0
|
|
}
|
|
},
|
|
message: e.message.charAt(0).toUpperCase() + e.message.substring(1),
|
|
severity: 1
|
|
});
|
|
}
|
|
return filterDiagnostics(errors, this.optionsToFilterDiagnostics);
|
|
}
|
|
constructor(mode){
|
|
super(mode);
|
|
php_service_define_property(this, "$service", void 0);
|
|
php_service_define_property(this, "serviceCapabilities", {
|
|
diagnosticProvider: {
|
|
interFileDependencies: true,
|
|
workspaceDiagnostics: true
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
})();
|
|
|
|
/******/ return __webpack_exports__;
|
|
/******/ })()
|
|
;
|
|
}); |