(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
};

/***/ }),

/***/ 7991:
/***/ ((__unused_webpack_module, exports) => {

"use strict";


exports.byteLength = byteLength
exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray

var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array

var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
for (var i = 0, len = code.length; i < len; ++i) {
  lookup[i] = code[i]
  revLookup[code.charCodeAt(i)] = i
}

// Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
revLookup['-'.charCodeAt(0)] = 62
revLookup['_'.charCodeAt(0)] = 63

function getLens (b64) {
  var len = b64.length

  if (len % 4 > 0) {
    throw new Error('Invalid string. Length must be a multiple of 4')
  }

  // Trim off extra bytes after placeholder bytes are found
  // See: https://github.com/beatgammit/base64-js/issues/42
  var validLen = b64.indexOf('=')
  if (validLen === -1) validLen = len

  var placeHoldersLen = validLen === len
    ? 0
    : 4 - (validLen % 4)

  return [validLen, placeHoldersLen]
}

// base64 is 4/3 + up to two characters of the original data
function byteLength (b64) {
  var lens = getLens(b64)
  var validLen = lens[0]
  var placeHoldersLen = lens[1]
  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}

function _byteLength (b64, validLen, placeHoldersLen) {
  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}

function toByteArray (b64) {
  var tmp
  var lens = getLens(b64)
  var validLen = lens[0]
  var placeHoldersLen = lens[1]

  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))

  var curByte = 0

  // if there are placeholders, only get up to the last complete 4 chars
  var len = placeHoldersLen > 0
    ? validLen - 4
    : validLen

  var i
  for (i = 0; i < len; i += 4) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 18) |
      (revLookup[b64.charCodeAt(i + 1)] << 12) |
      (revLookup[b64.charCodeAt(i + 2)] << 6) |
      revLookup[b64.charCodeAt(i + 3)]
    arr[curByte++] = (tmp >> 16) & 0xFF
    arr[curByte++] = (tmp >> 8) & 0xFF
    arr[curByte++] = tmp & 0xFF
  }

  if (placeHoldersLen === 2) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 2) |
      (revLookup[b64.charCodeAt(i + 1)] >> 4)
    arr[curByte++] = tmp & 0xFF
  }

  if (placeHoldersLen === 1) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 10) |
      (revLookup[b64.charCodeAt(i + 1)] << 4) |
      (revLookup[b64.charCodeAt(i + 2)] >> 2)
    arr[curByte++] = (tmp >> 8) & 0xFF
    arr[curByte++] = tmp & 0xFF
  }

  return arr
}

function tripletToBase64 (num) {
  return lookup[num >> 18 & 0x3F] +
    lookup[num >> 12 & 0x3F] +
    lookup[num >> 6 & 0x3F] +
    lookup[num & 0x3F]
}

function encodeChunk (uint8, start, end) {
  var tmp
  var output = []
  for (var i = start; i < end; i += 3) {
    tmp =
      ((uint8[i] << 16) & 0xFF0000) +
      ((uint8[i + 1] << 8) & 0xFF00) +
      (uint8[i + 2] & 0xFF)
    output.push(tripletToBase64(tmp))
  }
  return output.join('')
}

function fromByteArray (uint8) {
  var tmp
  var len = uint8.length
  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
  var parts = []
  var maxChunkLength = 16383 // must be multiple of 3

  // go through the array every three bytes, we'll deal with trailing stuff later
  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
  }

  // pad the end with zeros, but make sure to not forget the extra bytes
  if (extraBytes === 1) {
    tmp = uint8[len - 1]
    parts.push(
      lookup[tmp >> 2] +
      lookup[(tmp << 4) & 0x3F] +
      '=='
    )
  } else if (extraBytes === 2) {
    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
    parts.push(
      lookup[tmp >> 10] +
      lookup[(tmp >> 4) & 0x3F] +
      lookup[(tmp << 2) & 0x3F] +
      '='
    )
  }

  return parts.join('')
}


/***/ }),

/***/ 1048:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
var __webpack_unused_export__;
/* provided dependency */ var console = __webpack_require__(4364);
/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <https://feross.org>
 * @license  MIT
 */
/* eslint-disable no-proto */



const base64 = __webpack_require__(7991)
const ieee754 = __webpack_require__(9318)
const customInspectSymbol =
  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation
    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation
    : null

exports.hp = Buffer
__webpack_unused_export__ = SlowBuffer
exports.IS = 50

const K_MAX_LENGTH = 0x7fffffff
__webpack_unused_export__ = K_MAX_LENGTH

/**
 * If `Buffer.TYPED_ARRAY_SUPPORT`:
 *   === true    Use Uint8Array implementation (fastest)
 *   === false   Print warning and recommend using `buffer` v4.x which has an Object
 *               implementation (most compatible, even IE6)
 *
 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
 * Opera 11.6+, iOS 4.2+.
 *
 * We report that the browser does not support typed arrays if the are not subclassable
 * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
 * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
 * for __proto__ and has a buggy typed array implementation.
 */
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()

if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
    typeof console.error === 'function') {
  console.error(
    'This browser lacks typed array (Uint8Array) support which is required by ' +
    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
  )
}

function typedArraySupport () {
  // Can typed array instances can be augmented?
  try {
    const arr = new Uint8Array(1)
    const proto = { foo: function () { return 42 } }
    Object.setPrototypeOf(proto, Uint8Array.prototype)
    Object.setPrototypeOf(arr, proto)
    return arr.foo() === 42
  } catch (e) {
    return false
  }
}

Object.defineProperty(Buffer.prototype, 'parent', {
  enumerable: true,
  get: function () {
    if (!Buffer.isBuffer(this)) return undefined
    return this.buffer
  }
})

Object.defineProperty(Buffer.prototype, 'offset', {
  enumerable: true,
  get: function () {
    if (!Buffer.isBuffer(this)) return undefined
    return this.byteOffset
  }
})

function createBuffer (length) {
  if (length > K_MAX_LENGTH) {
    throw new RangeError('The value "' + length + '" is invalid for option "size"')
  }
  // Return an augmented `Uint8Array` instance
  const buf = new Uint8Array(length)
  Object.setPrototypeOf(buf, Buffer.prototype)
  return buf
}

/**
 * The Buffer constructor returns instances of `Uint8Array` that have their
 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
 * returns a single octet.
 *
 * The `Uint8Array` prototype remains unmodified.
 */

function Buffer (arg, encodingOrOffset, length) {
  // Common case.
  if (typeof arg === 'number') {
    if (typeof encodingOrOffset === 'string') {
      throw new TypeError(
        'The "string" argument must be of type string. Received type number'
      )
    }
    return allocUnsafe(arg)
  }
  return from(arg, encodingOrOffset, length)
}

Buffer.poolSize = 8192 // not used by this implementation

function from (value, encodingOrOffset, length) {
  if (typeof value === 'string') {
    return fromString(value, encodingOrOffset)
  }

  if (ArrayBuffer.isView(value)) {
    return fromArrayView(value)
  }

  if (value == null) {
    throw new TypeError(
      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
      'or Array-like Object. Received type ' + (typeof value)
    )
  }

  if (isInstance(value, ArrayBuffer) ||
      (value && isInstance(value.buffer, ArrayBuffer))) {
    return fromArrayBuffer(value, encodingOrOffset, length)
  }

  if (typeof SharedArrayBuffer !== 'undefined' &&
      (isInstance(value, SharedArrayBuffer) ||
      (value && isInstance(value.buffer, SharedArrayBuffer)))) {
    return fromArrayBuffer(value, encodingOrOffset, length)
  }

  if (typeof value === 'number') {
    throw new TypeError(
      'The "value" argument must not be of type number. Received type number'
    )
  }

  const valueOf = value.valueOf && value.valueOf()
  if (valueOf != null && valueOf !== value) {
    return Buffer.from(valueOf, encodingOrOffset, length)
  }

  const b = fromObject(value)
  if (b) return b

  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
      typeof value[Symbol.toPrimitive] === 'function') {
    return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)
  }

  throw new TypeError(
    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
    'or Array-like Object. Received type ' + (typeof value)
  )
}

/**
 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
 * if value is a number.
 * Buffer.from(str[, encoding])
 * Buffer.from(array)
 * Buffer.from(buffer)
 * Buffer.from(arrayBuffer[, byteOffset[, length]])
 **/
Buffer.from = function (value, encodingOrOffset, length) {
  return from(value, encodingOrOffset, length)
}

// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
// https://github.com/feross/buffer/pull/148
Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)
Object.setPrototypeOf(Buffer, Uint8Array)

function assertSize (size) {
  if (typeof size !== 'number') {
    throw new TypeError('"size" argument must be of type number')
  } else if (size < 0) {
    throw new RangeError('The value "' + size + '" is invalid for option "size"')
  }
}

function alloc (size, fill, encoding) {
  assertSize(size)
  if (size <= 0) {
    return createBuffer(size)
  }
  if (fill !== undefined) {
    // Only pay attention to encoding if it's a string. This
    // prevents accidentally sending in a number that would
    // be interpreted as a start offset.
    return typeof encoding === 'string'
      ? createBuffer(size).fill(fill, encoding)
      : createBuffer(size).fill(fill)
  }
  return createBuffer(size)
}

/**
 * Creates a new filled Buffer instance.
 * alloc(size[, fill[, encoding]])
 **/
Buffer.alloc = function (size, fill, encoding) {
  return alloc(size, fill, encoding)
}

function allocUnsafe (size) {
  assertSize(size)
  return createBuffer(size < 0 ? 0 : checked(size) | 0)
}

/**
 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
 * */
Buffer.allocUnsafe = function (size) {
  return allocUnsafe(size)
}
/**
 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
 */
Buffer.allocUnsafeSlow = function (size) {
  return allocUnsafe(size)
}

function fromString (string, encoding) {
  if (typeof encoding !== 'string' || encoding === '') {
    encoding = 'utf8'
  }

  if (!Buffer.isEncoding(encoding)) {
    throw new TypeError('Unknown encoding: ' + encoding)
  }

  const length = byteLength(string, encoding) | 0
  let buf = createBuffer(length)

  const actual = buf.write(string, encoding)

  if (actual !== length) {
    // Writing a hex string, for example, that contains invalid characters will
    // cause everything after the first invalid character to be ignored. (e.g.
    // 'abxxcd' will be treated as 'ab')
    buf = buf.slice(0, actual)
  }

  return buf
}

function fromArrayLike (array) {
  const length = array.length < 0 ? 0 : checked(array.length) | 0
  const buf = createBuffer(length)
  for (let i = 0; i < length; i += 1) {
    buf[i] = array[i] & 255
  }
  return buf
}

function fromArrayView (arrayView) {
  if (isInstance(arrayView, Uint8Array)) {
    const copy = new Uint8Array(arrayView)
    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)
  }
  return fromArrayLike(arrayView)
}

function fromArrayBuffer (array, byteOffset, length) {
  if (byteOffset < 0 || array.byteLength < byteOffset) {
    throw new RangeError('"offset" is outside of buffer bounds')
  }

  if (array.byteLength < byteOffset + (length || 0)) {
    throw new RangeError('"length" is outside of buffer bounds')
  }

  let buf
  if (byteOffset === undefined && length === undefined) {
    buf = new Uint8Array(array)
  } else if (length === undefined) {
    buf = new Uint8Array(array, byteOffset)
  } else {
    buf = new Uint8Array(array, byteOffset, length)
  }

  // Return an augmented `Uint8Array` instance
  Object.setPrototypeOf(buf, Buffer.prototype)

  return buf
}

function fromObject (obj) {
  if (Buffer.isBuffer(obj)) {
    const len = checked(obj.length) | 0
    const buf = createBuffer(len)

    if (buf.length === 0) {
      return buf
    }

    obj.copy(buf, 0, 0, len)
    return buf
  }

  if (obj.length !== undefined) {
    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
      return createBuffer(0)
    }
    return fromArrayLike(obj)
  }

  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
    return fromArrayLike(obj.data)
  }
}

function checked (length) {
  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
  // length is NaN (which is otherwise coerced to zero.)
  if (length >= K_MAX_LENGTH) {
    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
  }
  return length | 0
}

function SlowBuffer (length) {
  if (+length != length) { // eslint-disable-line eqeqeq
    length = 0
  }
  return Buffer.alloc(+length)
}

Buffer.isBuffer = function isBuffer (b) {
  return b != null && b._isBuffer === true &&
    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
}

Buffer.compare = function compare (a, b) {
  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
    throw new TypeError(
      'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
    )
  }

  if (a === b) return 0

  let x = a.length
  let y = b.length

  for (let 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
}

Buffer.isEncoding = function isEncoding (encoding) {
  switch (String(encoding).toLowerCase()) {
    case 'hex':
    case 'utf8':
    case 'utf-8':
    case 'ascii':
    case 'latin1':
    case 'binary':
    case 'base64':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return true
    default:
      return false
  }
}

Buffer.concat = function concat (list, length) {
  if (!Array.isArray(list)) {
    throw new TypeError('"list" argument must be an Array of Buffers')
  }

  if (list.length === 0) {
    return Buffer.alloc(0)
  }

  let i
  if (length === undefined) {
    length = 0
    for (i = 0; i < list.length; ++i) {
      length += list[i].length
    }
  }

  const buffer = Buffer.allocUnsafe(length)
  let pos = 0
  for (i = 0; i < list.length; ++i) {
    let buf = list[i]
    if (isInstance(buf, Uint8Array)) {
      if (pos + buf.length > buffer.length) {
        if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)
        buf.copy(buffer, pos)
      } else {
        Uint8Array.prototype.set.call(
          buffer,
          buf,
          pos
        )
      }
    } else if (!Buffer.isBuffer(buf)) {
      throw new TypeError('"list" argument must be an Array of Buffers')
    } else {
      buf.copy(buffer, pos)
    }
    pos += buf.length
  }
  return buffer
}

function byteLength (string, encoding) {
  if (Buffer.isBuffer(string)) {
    return string.length
  }
  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
    return string.byteLength
  }
  if (typeof string !== 'string') {
    throw new TypeError(
      'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
      'Received type ' + typeof string
    )
  }

  const len = string.length
  const mustMatch = (arguments.length > 2 && arguments[2] === true)
  if (!mustMatch && len === 0) return 0

  // Use a for loop to avoid recursion
  let loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'ascii':
      case 'latin1':
      case 'binary':
        return len
      case 'utf8':
      case 'utf-8':
        return utf8ToBytes(string).length
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return len * 2
      case 'hex':
        return len >>> 1
      case 'base64':
        return base64ToBytes(string).length
      default:
        if (loweredCase) {
          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
        }
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}
Buffer.byteLength = byteLength

function slowToString (encoding, start, end) {
  let loweredCase = false

  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
  // property of a typed array.

  // This behaves neither like String nor Uint8Array in that we set start/end
  // to their upper/lower bounds if the value passed is out of range.
  // undefined is handled specially as per ECMA-262 6th Edition,
  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
  if (start === undefined || start < 0) {
    start = 0
  }
  // Return early if start > this.length. Done here to prevent potential uint32
  // coercion fail below.
  if (start > this.length) {
    return ''
  }

  if (end === undefined || end > this.length) {
    end = this.length
  }

  if (end <= 0) {
    return ''
  }

  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.
  end >>>= 0
  start >>>= 0

  if (end <= start) {
    return ''
  }

  if (!encoding) encoding = 'utf8'

  while (true) {
    switch (encoding) {
      case 'hex':
        return hexSlice(this, start, end)

      case 'utf8':
      case 'utf-8':
        return utf8Slice(this, start, end)

      case 'ascii':
        return asciiSlice(this, start, end)

      case 'latin1':
      case 'binary':
        return latin1Slice(this, start, end)

      case 'base64':
        return base64Slice(this, start, end)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return utf16leSlice(this, start, end)

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = (encoding + '').toLowerCase()
        loweredCase = true
    }
  }
}

// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
// reliably in a browserify context because there could be multiple different
// copies of the 'buffer' package in use. This method works even for Buffer
// instances that were created from another copy of the `buffer` package.
// See: https://github.com/feross/buffer/issues/154
Buffer.prototype._isBuffer = true

function swap (b, n, m) {
  const i = b[n]
  b[n] = b[m]
  b[m] = i
}

Buffer.prototype.swap16 = function swap16 () {
  const len = this.length
  if (len % 2 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 16-bits')
  }
  for (let i = 0; i < len; i += 2) {
    swap(this, i, i + 1)
  }
  return this
}

Buffer.prototype.swap32 = function swap32 () {
  const len = this.length
  if (len % 4 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 32-bits')
  }
  for (let i = 0; i < len; i += 4) {
    swap(this, i, i + 3)
    swap(this, i + 1, i + 2)
  }
  return this
}

Buffer.prototype.swap64 = function swap64 () {
  const len = this.length
  if (len % 8 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 64-bits')
  }
  for (let i = 0; i < len; i += 8) {
    swap(this, i, i + 7)
    swap(this, i + 1, i + 6)
    swap(this, i + 2, i + 5)
    swap(this, i + 3, i + 4)
  }
  return this
}

Buffer.prototype.toString = function toString () {
  const length = this.length
  if (length === 0) return ''
  if (arguments.length === 0) return utf8Slice(this, 0, length)
  return slowToString.apply(this, arguments)
}

Buffer.prototype.toLocaleString = Buffer.prototype.toString

Buffer.prototype.equals = function equals (b) {
  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
  if (this === b) return true
  return Buffer.compare(this, b) === 0
}

Buffer.prototype.inspect = function inspect () {
  let str = ''
  const max = exports.IS
  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
  if (this.length > max) str += ' ... '
  return '<Buffer ' + str + '>'
}
if (customInspectSymbol) {
  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect
}

Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
  if (isInstance(target, Uint8Array)) {
    target = Buffer.from(target, target.offset, target.byteLength)
  }
  if (!Buffer.isBuffer(target)) {
    throw new TypeError(
      'The "target" argument must be one of type Buffer or Uint8Array. ' +
      'Received type ' + (typeof target)
    )
  }

  if (start === undefined) {
    start = 0
  }
  if (end === undefined) {
    end = target ? target.length : 0
  }
  if (thisStart === undefined) {
    thisStart = 0
  }
  if (thisEnd === undefined) {
    thisEnd = this.length
  }

  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
    throw new RangeError('out of range index')
  }

  if (thisStart >= thisEnd && start >= end) {
    return 0
  }
  if (thisStart >= thisEnd) {
    return -1
  }
  if (start >= end) {
    return 1
  }

  start >>>= 0
  end >>>= 0
  thisStart >>>= 0
  thisEnd >>>= 0

  if (this === target) return 0

  let x = thisEnd - thisStart
  let y = end - start
  const len = Math.min(x, y)

  const thisCopy = this.slice(thisStart, thisEnd)
  const targetCopy = target.slice(start, end)

  for (let i = 0; i < len; ++i) {
    if (thisCopy[i] !== targetCopy[i]) {
      x = thisCopy[i]
      y = targetCopy[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
  // Empty buffer means no match
  if (buffer.length === 0) return -1

  // Normalize byteOffset
  if (typeof byteOffset === 'string') {
    encoding = byteOffset
    byteOffset = 0
  } else if (byteOffset > 0x7fffffff) {
    byteOffset = 0x7fffffff
  } else if (byteOffset < -0x80000000) {
    byteOffset = -0x80000000
  }
  byteOffset = +byteOffset // Coerce to Number.
  if (numberIsNaN(byteOffset)) {
    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
    byteOffset = dir ? 0 : (buffer.length - 1)
  }

  // Normalize byteOffset: negative offsets start from the end of the buffer
  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
  if (byteOffset >= buffer.length) {
    if (dir) return -1
    else byteOffset = buffer.length - 1
  } else if (byteOffset < 0) {
    if (dir) byteOffset = 0
    else return -1
  }

  // Normalize val
  if (typeof val === 'string') {
    val = Buffer.from(val, encoding)
  }

  // Finally, search either indexOf (if dir is true) or lastIndexOf
  if (Buffer.isBuffer(val)) {
    // Special case: looking for empty string/buffer always fails
    if (val.length === 0) {
      return -1
    }
    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
  } else if (typeof val === 'number') {
    val = val & 0xFF // Search for a byte value [0-255]
    if (typeof Uint8Array.prototype.indexOf === 'function') {
      if (dir) {
        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
      } else {
        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
      }
    }
    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)
  }

  throw new TypeError('val must be string, number or Buffer')
}

function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
  let indexSize = 1
  let arrLength = arr.length
  let valLength = val.length

  if (encoding !== undefined) {
    encoding = String(encoding).toLowerCase()
    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
        encoding === 'utf16le' || encoding === 'utf-16le') {
      if (arr.length < 2 || val.length < 2) {
        return -1
      }
      indexSize = 2
      arrLength /= 2
      valLength /= 2
      byteOffset /= 2
    }
  }

  function read (buf, i) {
    if (indexSize === 1) {
      return buf[i]
    } else {
      return buf.readUInt16BE(i * indexSize)
    }
  }

  let i
  if (dir) {
    let foundIndex = -1
    for (i = byteOffset; i < arrLength; i++) {
      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
        if (foundIndex === -1) foundIndex = i
        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
      } else {
        if (foundIndex !== -1) i -= i - foundIndex
        foundIndex = -1
      }
    }
  } else {
    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
    for (i = byteOffset; i >= 0; i--) {
      let found = true
      for (let j = 0; j < valLength; j++) {
        if (read(arr, i + j) !== read(val, j)) {
          found = false
          break
        }
      }
      if (found) return i
    }
  }

  return -1
}

Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
  return this.indexOf(val, byteOffset, encoding) !== -1
}

Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}

Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}

function hexWrite (buf, string, offset, length) {
  offset = Number(offset) || 0
  const remaining = buf.length - offset
  if (!length) {
    length = remaining
  } else {
    length = Number(length)
    if (length > remaining) {
      length = remaining
    }
  }

  const strLen = string.length

  if (length > strLen / 2) {
    length = strLen / 2
  }
  let i
  for (i = 0; i < length; ++i) {
    const parsed = parseInt(string.substr(i * 2, 2), 16)
    if (numberIsNaN(parsed)) return i
    buf[offset + i] = parsed
  }
  return i
}

function utf8Write (buf, string, offset, length) {
  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}

function asciiWrite (buf, string, offset, length) {
  return blitBuffer(asciiToBytes(string), buf, offset, length)
}

function base64Write (buf, string, offset, length) {
  return blitBuffer(base64ToBytes(string), buf, offset, length)
}

function ucs2Write (buf, string, offset, length) {
  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}

Buffer.prototype.write = function write (string, offset, length, encoding) {
  // Buffer#write(string)
  if (offset === undefined) {
    encoding = 'utf8'
    length = this.length
    offset = 0
  // Buffer#write(string, encoding)
  } else if (length === undefined && typeof offset === 'string') {
    encoding = offset
    length = this.length
    offset = 0
  // Buffer#write(string, offset[, length][, encoding])
  } else if (isFinite(offset)) {
    offset = offset >>> 0
    if (isFinite(length)) {
      length = length >>> 0
      if (encoding === undefined) encoding = 'utf8'
    } else {
      encoding = length
      length = undefined
    }
  } else {
    throw new Error(
      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
    )
  }

  const remaining = this.length - offset
  if (length === undefined || length > remaining) length = remaining

  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
    throw new RangeError('Attempt to write outside buffer bounds')
  }

  if (!encoding) encoding = 'utf8'

  let loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'hex':
        return hexWrite(this, string, offset, length)

      case 'utf8':
      case 'utf-8':
        return utf8Write(this, string, offset, length)

      case 'ascii':
      case 'latin1':
      case 'binary':
        return asciiWrite(this, string, offset, length)

      case 'base64':
        // Warning: maxLength not taken into account in base64Write
        return base64Write(this, string, offset, length)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return ucs2Write(this, string, offset, length)

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}

Buffer.prototype.toJSON = function toJSON () {
  return {
    type: 'Buffer',
    data: Array.prototype.slice.call(this._arr || this, 0)
  }
}

function base64Slice (buf, start, end) {
  if (start === 0 && end === buf.length) {
    return base64.fromByteArray(buf)
  } else {
    return base64.fromByteArray(buf.slice(start, end))
  }
}

function utf8Slice (buf, start, end) {
  end = Math.min(buf.length, end)
  const res = []

  let i = start
  while (i < end) {
    const firstByte = buf[i]
    let codePoint = null
    let bytesPerSequence = (firstByte > 0xEF)
      ? 4
      : (firstByte > 0xDF)
          ? 3
          : (firstByte > 0xBF)
              ? 2
              : 1

    if (i + bytesPerSequence <= end) {
      let secondByte, thirdByte, fourthByte, tempCodePoint

      switch (bytesPerSequence) {
        case 1:
          if (firstByte < 0x80) {
            codePoint = firstByte
          }
          break
        case 2:
          secondByte = buf[i + 1]
          if ((secondByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
            if (tempCodePoint > 0x7F) {
              codePoint = tempCodePoint
            }
          }
          break
        case 3:
          secondByte = buf[i + 1]
          thirdByte = buf[i + 2]
          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
              codePoint = tempCodePoint
            }
          }
          break
        case 4:
          secondByte = buf[i + 1]
          thirdByte = buf[i + 2]
          fourthByte = buf[i + 3]
          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
              codePoint = tempCodePoint
            }
          }
      }
    }

    if (codePoint === null) {
      // we did not generate a valid codePoint so insert a
      // replacement char (U+FFFD) and advance only 1 byte
      codePoint = 0xFFFD
      bytesPerSequence = 1
    } else if (codePoint > 0xFFFF) {
      // encode to utf16 (surrogate pair dance)
      codePoint -= 0x10000
      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
      codePoint = 0xDC00 | codePoint & 0x3FF
    }

    res.push(codePoint)
    i += bytesPerSequence
  }

  return decodeCodePointsArray(res)
}

// Based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
const MAX_ARGUMENTS_LENGTH = 0x1000

function decodeCodePointsArray (codePoints) {
  const len = codePoints.length
  if (len <= MAX_ARGUMENTS_LENGTH) {
    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
  }

  // Decode in chunks to avoid "call stack size exceeded".
  let res = ''
  let i = 0
  while (i < len) {
    res += String.fromCharCode.apply(
      String,
      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
    )
  }
  return res
}

function asciiSlice (buf, start, end) {
  let ret = ''
  end = Math.min(buf.length, end)

  for (let i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i] & 0x7F)
  }
  return ret
}

function latin1Slice (buf, start, end) {
  let ret = ''
  end = Math.min(buf.length, end)

  for (let i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i])
  }
  return ret
}

function hexSlice (buf, start, end) {
  const len = buf.length

  if (!start || start < 0) start = 0
  if (!end || end < 0 || end > len) end = len

  let out = ''
  for (let i = start; i < end; ++i) {
    out += hexSliceLookupTable[buf[i]]
  }
  return out
}

function utf16leSlice (buf, start, end) {
  const bytes = buf.slice(start, end)
  let res = ''
  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)
  for (let i = 0; i < bytes.length - 1; i += 2) {
    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
  }
  return res
}

Buffer.prototype.slice = function slice (start, end) {
  const len = this.length
  start = ~~start
  end = end === undefined ? len : ~~end

  if (start < 0) {
    start += len
    if (start < 0) start = 0
  } else if (start > len) {
    start = len
  }

  if (end < 0) {
    end += len
    if (end < 0) end = 0
  } else if (end > len) {
    end = len
  }

  if (end < start) end = start

  const newBuf = this.subarray(start, end)
  // Return an augmented `Uint8Array` instance
  Object.setPrototypeOf(newBuf, Buffer.prototype)

  return newBuf
}

/*
 * Need to make sure that buffer isn't trying to write out of bounds.
 */
function checkOffset (offset, ext, length) {
  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}

Buffer.prototype.readUintLE =
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  let val = this[offset]
  let mul = 1
  let i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }

  return val
}

Buffer.prototype.readUintBE =
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    checkOffset(offset, byteLength, this.length)
  }

  let val = this[offset + --byteLength]
  let mul = 1
  while (byteLength > 0 && (mul *= 0x100)) {
    val += this[offset + --byteLength] * mul
  }

  return val
}

Buffer.prototype.readUint8 =
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 1, this.length)
  return this[offset]
}

Buffer.prototype.readUint16LE =
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  return this[offset] | (this[offset + 1] << 8)
}

Buffer.prototype.readUint16BE =
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  return (this[offset] << 8) | this[offset + 1]
}

Buffer.prototype.readUint32LE =
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return ((this[offset]) |
      (this[offset + 1] << 8) |
      (this[offset + 2] << 16)) +
      (this[offset + 3] * 0x1000000)
}

Buffer.prototype.readUint32BE =
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset] * 0x1000000) +
    ((this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    this[offset + 3])
}

Buffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {
  offset = offset >>> 0
  validateNumber(offset, 'offset')
  const first = this[offset]
  const last = this[offset + 7]
  if (first === undefined || last === undefined) {
    boundsError(offset, this.length - 8)
  }

  const lo = first +
    this[++offset] * 2 ** 8 +
    this[++offset] * 2 ** 16 +
    this[++offset] * 2 ** 24

  const hi = this[++offset] +
    this[++offset] * 2 ** 8 +
    this[++offset] * 2 ** 16 +
    last * 2 ** 24

  return BigInt(lo) + (BigInt(hi) << BigInt(32))
})

Buffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {
  offset = offset >>> 0
  validateNumber(offset, 'offset')
  const first = this[offset]
  const last = this[offset + 7]
  if (first === undefined || last === undefined) {
    boundsError(offset, this.length - 8)
  }

  const hi = first * 2 ** 24 +
    this[++offset] * 2 ** 16 +
    this[++offset] * 2 ** 8 +
    this[++offset]

  const lo = this[++offset] * 2 ** 24 +
    this[++offset] * 2 ** 16 +
    this[++offset] * 2 ** 8 +
    last

  return (BigInt(hi) << BigInt(32)) + BigInt(lo)
})

Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  let val = this[offset]
  let mul = 1
  let i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= Math.pow(2, 8 * byteLength)

  return val
}

Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  let i = byteLength
  let mul = 1
  let val = this[offset + --i]
  while (i > 0 && (mul *= 0x100)) {
    val += this[offset + --i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= Math.pow(2, 8 * byteLength)

  return val
}

Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 1, this.length)
  if (!(this[offset] & 0x80)) return (this[offset])
  return ((0xff - this[offset] + 1) * -1)
}

Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  const val = this[offset] | (this[offset + 1] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  const val = this[offset + 1] | (this[offset] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset]) |
    (this[offset + 1] << 8) |
    (this[offset + 2] << 16) |
    (this[offset + 3] << 24)
}

Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset] << 24) |
    (this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    (this[offset + 3])
}

Buffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {
  offset = offset >>> 0
  validateNumber(offset, 'offset')
  const first = this[offset]
  const last = this[offset + 7]
  if (first === undefined || last === undefined) {
    boundsError(offset, this.length - 8)
  }

  const val = this[offset + 4] +
    this[offset + 5] * 2 ** 8 +
    this[offset + 6] * 2 ** 16 +
    (last << 24) // Overflow

  return (BigInt(val) << BigInt(32)) +
    BigInt(first +
    this[++offset] * 2 ** 8 +
    this[++offset] * 2 ** 16 +
    this[++offset] * 2 ** 24)
})

Buffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {
  offset = offset >>> 0
  validateNumber(offset, 'offset')
  const first = this[offset]
  const last = this[offset + 7]
  if (first === undefined || last === undefined) {
    boundsError(offset, this.length - 8)
  }

  const val = (first << 24) + // Overflow
    this[++offset] * 2 ** 16 +
    this[++offset] * 2 ** 8 +
    this[++offset]

  return (BigInt(val) << BigInt(32)) +
    BigInt(this[++offset] * 2 ** 24 +
    this[++offset] * 2 ** 16 +
    this[++offset] * 2 ** 8 +
    last)
})

Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, true, 23, 4)
}

Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, false, 23, 4)
}

Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, true, 52, 8)
}

Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, false, 52, 8)
}

function checkInt (buf, value, offset, ext, max, min) {
  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
  if (offset + ext > buf.length) throw new RangeError('Index out of range')
}

Buffer.prototype.writeUintLE =
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    const maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

  let mul = 1
  let i = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeUintBE =
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    const maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

  let i = byteLength - 1
  let mul = 1
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeUint8 =
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
  this[offset] = (value & 0xff)
  return offset + 1
}

Buffer.prototype.writeUint16LE =
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  return offset + 2
}

Buffer.prototype.writeUint16BE =
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  this[offset] = (value >>> 8)
  this[offset + 1] = (value & 0xff)
  return offset + 2
}

Buffer.prototype.writeUint32LE =
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  this[offset + 3] = (value >>> 24)
  this[offset + 2] = (value >>> 16)
  this[offset + 1] = (value >>> 8)
  this[offset] = (value & 0xff)
  return offset + 4
}

Buffer.prototype.writeUint32BE =
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  this[offset] = (value >>> 24)
  this[offset + 1] = (value >>> 16)
  this[offset + 2] = (value >>> 8)
  this[offset + 3] = (value & 0xff)
  return offset + 4
}

function wrtBigUInt64LE (buf, value, offset, min, max) {
  checkIntBI(value, min, max, buf, offset, 7)

  let lo = Number(value & BigInt(0xffffffff))
  buf[offset++] = lo
  lo = lo >> 8
  buf[offset++] = lo
  lo = lo >> 8
  buf[offset++] = lo
  lo = lo >> 8
  buf[offset++] = lo
  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))
  buf[offset++] = hi
  hi = hi >> 8
  buf[offset++] = hi
  hi = hi >> 8
  buf[offset++] = hi
  hi = hi >> 8
  buf[offset++] = hi
  return offset
}

function wrtBigUInt64BE (buf, value, offset, min, max) {
  checkIntBI(value, min, max, buf, offset, 7)

  let lo = Number(value & BigInt(0xffffffff))
  buf[offset + 7] = lo
  lo = lo >> 8
  buf[offset + 6] = lo
  lo = lo >> 8
  buf[offset + 5] = lo
  lo = lo >> 8
  buf[offset + 4] = lo
  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))
  buf[offset + 3] = hi
  hi = hi >> 8
  buf[offset + 2] = hi
  hi = hi >> 8
  buf[offset + 1] = hi
  hi = hi >> 8
  buf[offset] = hi
  return offset + 8
}

Buffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {
  return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))
})

Buffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {
  return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))
})

Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    const limit = Math.pow(2, (8 * byteLength) - 1)

    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

  let i = 0
  let mul = 1
  let sub = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    const limit = Math.pow(2, (8 * byteLength) - 1)

    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

  let i = byteLength - 1
  let mul = 1
  let sub = 0
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
  if (value < 0) value = 0xff + value + 1
  this[offset] = (value & 0xff)
  return offset + 1
}

Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  return offset + 2
}

Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  this[offset] = (value >>> 8)
  this[offset + 1] = (value & 0xff)
  return offset + 2
}

Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  this[offset + 2] = (value >>> 16)
  this[offset + 3] = (value >>> 24)
  return offset + 4
}

Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  if (value < 0) value = 0xffffffff + value + 1
  this[offset] = (value >>> 24)
  this[offset + 1] = (value >>> 16)
  this[offset + 2] = (value >>> 8)
  this[offset + 3] = (value & 0xff)
  return offset + 4
}

Buffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {
  return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))
})

Buffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {
  return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))
})

function checkIEEE754 (buf, value, offset, ext, max, min) {
  if (offset + ext > buf.length) throw new RangeError('Index out of range')
  if (offset < 0) throw new RangeError('Index out of range')
}

function writeFloat (buf, value, offset, littleEndian, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
  }
  ieee754.write(buf, value, offset, littleEndian, 23, 4)
  return offset + 4
}

Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
  return writeFloat(this, value, offset, true, noAssert)
}

Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
  return writeFloat(this, value, offset, false, noAssert)
}

function writeDouble (buf, value, offset, littleEndian, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
  }
  ieee754.write(buf, value, offset, littleEndian, 52, 8)
  return offset + 8
}

Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
  return writeDouble(this, value, offset, true, noAssert)
}

Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
  return writeDouble(this, value, offset, false, noAssert)
}

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
  if (!start) start = 0
  if (!end && end !== 0) end = this.length
  if (targetStart >= target.length) targetStart = target.length
  if (!targetStart) targetStart = 0
  if (end > 0 && end < start) end = start

  // Copy 0 bytes; we're done
  if (end === start) return 0
  if (target.length === 0 || this.length === 0) return 0

  // Fatal error conditions
  if (targetStart < 0) {
    throw new RangeError('targetStart out of bounds')
  }
  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
  if (end < 0) throw new RangeError('sourceEnd out of bounds')

  // Are we oob?
  if (end > this.length) end = this.length
  if (target.length - targetStart < end - start) {
    end = target.length - targetStart + start
  }

  const len = end - start

  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
    // Use built-in when available, missing from IE11
    this.copyWithin(targetStart, start, end)
  } else {
    Uint8Array.prototype.set.call(
      target,
      this.subarray(start, end),
      targetStart
    )
  }

  return len
}

// Usage:
//    buffer.fill(number[, offset[, end]])
//    buffer.fill(buffer[, offset[, end]])
//    buffer.fill(string[, offset[, end]][, encoding])
Buffer.prototype.fill = function fill (val, start, end, encoding) {
  // Handle string cases:
  if (typeof val === 'string') {
    if (typeof start === 'string') {
      encoding = start
      start = 0
      end = this.length
    } else if (typeof end === 'string') {
      encoding = end
      end = this.length
    }
    if (encoding !== undefined && typeof encoding !== 'string') {
      throw new TypeError('encoding must be a string')
    }
    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
      throw new TypeError('Unknown encoding: ' + encoding)
    }
    if (val.length === 1) {
      const code = val.charCodeAt(0)
      if ((encoding === 'utf8' && code < 128) ||
          encoding === 'latin1') {
        // Fast path: If `val` fits into a single byte, use that numeric value.
        val = code
      }
    }
  } else if (typeof val === 'number') {
    val = val & 255
  } else if (typeof val === 'boolean') {
    val = Number(val)
  }

  // Invalid ranges are not set to a default, so can range check early.
  if (start < 0 || this.length < start || this.length < end) {
    throw new RangeError('Out of range index')
  }

  if (end <= start) {
    return this
  }

  start = start >>> 0
  end = end === undefined ? this.length : end >>> 0

  if (!val) val = 0

  let i
  if (typeof val === 'number') {
    for (i = start; i < end; ++i) {
      this[i] = val
    }
  } else {
    const bytes = Buffer.isBuffer(val)
      ? val
      : Buffer.from(val, encoding)
    const len = bytes.length
    if (len === 0) {
      throw new TypeError('The value "' + val +
        '" is invalid for argument "value"')
    }
    for (i = 0; i < end - start; ++i) {
      this[i + start] = bytes[i % len]
    }
  }

  return this
}

// CUSTOM ERRORS
// =============

// Simplified versions from Node, changed for Buffer-only usage
const errors = {}
function E (sym, getMessage, Base) {
  errors[sym] = class NodeError extends Base {
    constructor () {
      super()

      Object.defineProperty(this, 'message', {
        value: getMessage.apply(this, arguments),
        writable: true,
        configurable: true
      })

      // Add the error code to the name to include it in the stack trace.
      this.name = `${this.name} [${sym}]`
      // Access the stack to generate the error message including the error code
      // from the name.
      this.stack // eslint-disable-line no-unused-expressions
      // Reset the name to the actual name.
      delete this.name
    }

    get code () {
      return sym
    }

    set code (value) {
      Object.defineProperty(this, 'code', {
        configurable: true,
        enumerable: true,
        value,
        writable: true
      })
    }

    toString () {
      return `${this.name} [${sym}]: ${this.message}`
    }
  }
}

E('ERR_BUFFER_OUT_OF_BOUNDS',
  function (name) {
    if (name) {
      return `${name} is outside of buffer bounds`
    }

    return 'Attempt to access memory outside buffer bounds'
  }, RangeError)
E('ERR_INVALID_ARG_TYPE',
  function (name, actual) {
    return `The "${name}" argument must be of type number. Received type ${typeof actual}`
  }, TypeError)
E('ERR_OUT_OF_RANGE',
  function (str, range, input) {
    let msg = `The value of "${str}" is out of range.`
    let received = input
    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
      received = addNumericalSeparator(String(input))
    } else if (typeof input === 'bigint') {
      received = String(input)
      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
        received = addNumericalSeparator(received)
      }
      received += 'n'
    }
    msg += ` It must be ${range}. Received ${received}`
    return msg
  }, RangeError)

function addNumericalSeparator (val) {
  let res = ''
  let i = val.length
  const start = val[0] === '-' ? 1 : 0
  for (; i >= start + 4; i -= 3) {
    res = `_${val.slice(i - 3, i)}${res}`
  }
  return `${val.slice(0, i)}${res}`
}

// CHECK FUNCTIONS
// ===============

function checkBounds (buf, offset, byteLength) {
  validateNumber(offset, 'offset')
  if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {
    boundsError(offset, buf.length - (byteLength + 1))
  }
}

function checkIntBI (value, min, max, buf, offset, byteLength) {
  if (value > max || value < min) {
    const n = typeof min === 'bigint' ? 'n' : ''
    let range
    if (byteLength > 3) {
      if (min === 0 || min === BigInt(0)) {
        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`
      } else {
        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +
                `${(byteLength + 1) * 8 - 1}${n}`
      }
    } else {
      range = `>= ${min}${n} and <= ${max}${n}`
    }
    throw new errors.ERR_OUT_OF_RANGE('value', range, value)
  }
  checkBounds(buf, offset, byteLength)
}

function validateNumber (value, name) {
  if (typeof value !== 'number') {
    throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)
  }
}

function boundsError (value, length, type) {
  if (Math.floor(value) !== value) {
    validateNumber(value, type)
    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)
  }

  if (length < 0) {
    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()
  }

  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',
                                    `>= ${type ? 1 : 0} and <= ${length}`,
                                    value)
}

// HELPER FUNCTIONS
// ================

const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g

function base64clean (str) {
  // Node takes equal signs as end of the Base64 encoding
  str = str.split('=')[0]
  // Node strips out invalid characters like \n and \t from the string, base64-js does not
  str = str.trim().replace(INVALID_BASE64_RE, '')
  // Node converts strings with length < 2 to ''
  if (str.length < 2) return ''
  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
  while (str.length % 4 !== 0) {
    str = str + '='
  }
  return str
}

function utf8ToBytes (string, units) {
  units = units || Infinity
  let codePoint
  const length = string.length
  let leadSurrogate = null
  const bytes = []

  for (let i = 0; i < length; ++i) {
    codePoint = string.charCodeAt(i)

    // is surrogate component
    if (codePoint > 0xD7FF && codePoint < 0xE000) {
      // last char was a lead
      if (!leadSurrogate) {
        // no lead yet
        if (codePoint > 0xDBFF) {
          // unexpected trail
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          continue
        } else if (i + 1 === length) {
          // unpaired lead
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          continue
        }

        // valid lead
        leadSurrogate = codePoint

        continue
      }

      // 2 leads in a row
      if (codePoint < 0xDC00) {
        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
        leadSurrogate = codePoint
        continue
      }

      // valid surrogate pair
      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
    } else if (leadSurrogate) {
      // valid bmp char, but last char was a lead
      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
    }

    leadSurrogate = null

    // encode utf8
    if (codePoint < 0x80) {
      if ((units -= 1) < 0) break
      bytes.push(codePoint)
    } else if (codePoint < 0x800) {
      if ((units -= 2) < 0) break
      bytes.push(
        codePoint >> 0x6 | 0xC0,
        codePoint & 0x3F | 0x80
      )
    } else if (codePoint < 0x10000) {
      if ((units -= 3) < 0) break
      bytes.push(
        codePoint >> 0xC | 0xE0,
        codePoint >> 0x6 & 0x3F | 0x80,
        codePoint & 0x3F | 0x80
      )
    } else if (codePoint < 0x110000) {
      if ((units -= 4) < 0) break
      bytes.push(
        codePoint >> 0x12 | 0xF0,
        codePoint >> 0xC & 0x3F | 0x80,
        codePoint >> 0x6 & 0x3F | 0x80,
        codePoint & 0x3F | 0x80
      )
    } else {
      throw new Error('Invalid code point')
    }
  }

  return bytes
}

function asciiToBytes (str) {
  const byteArray = []
  for (let i = 0; i < str.length; ++i) {
    // Node's code seems to be doing this and not & 0x7F..
    byteArray.push(str.charCodeAt(i) & 0xFF)
  }
  return byteArray
}

function utf16leToBytes (str, units) {
  let c, hi, lo
  const byteArray = []
  for (let i = 0; i < str.length; ++i) {
    if ((units -= 2) < 0) break

    c = str.charCodeAt(i)
    hi = c >> 8
    lo = c % 256
    byteArray.push(lo)
    byteArray.push(hi)
  }

  return byteArray
}

function base64ToBytes (str) {
  return base64.toByteArray(base64clean(str))
}

function blitBuffer (src, dst, offset, length) {
  let i
  for (i = 0; i < length; ++i) {
    if ((i + offset >= dst.length) || (i >= src.length)) break
    dst[i + offset] = src[i]
  }
  return i
}

// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
// the `instanceof` check but they should be treated as of that type.
// See: https://github.com/feross/buffer/issues/166
function isInstance (obj, type) {
  return obj instanceof type ||
    (obj != null && obj.constructor != null && obj.constructor.name != null &&
      obj.constructor.name === type.name)
}
function numberIsNaN (obj) {
  // For IE11 support
  return obj !== obj // eslint-disable-line no-self-compare
}

// Create lookup table for `toString('hex')`
// See: https://github.com/feross/buffer/issues/219
const hexSliceLookupTable = (function () {
  const alphabet = '0123456789abcdef'
  const table = new Array(256)
  for (let i = 0; i < 16; ++i) {
    const i16 = i * 16
    for (let j = 0; j < 16; ++j) {
      table[i16 + j] = alphabet[i] + alphabet[j]
    }
  }
  return table
})()

// Return not function with Error if BigInt not supported
function defineBigIntMethod (fn) {
  return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn
}

function BufferBigIntNotDefined () {
  throw new Error('BigInt not supported')
}


/***/ }),

/***/ 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);


/***/ }),

/***/ 9318:
/***/ ((__unused_webpack_module, exports) => {

/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
  var e, m
  var eLen = (nBytes * 8) - mLen - 1
  var eMax = (1 << eLen) - 1
  var eBias = eMax >> 1
  var nBits = -7
  var i = isLE ? (nBytes - 1) : 0
  var d = isLE ? -1 : 1
  var s = buffer[offset + i]

  i += d

  e = s & ((1 << (-nBits)) - 1)
  s >>= (-nBits)
  nBits += eLen
  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}

  m = e & ((1 << (-nBits)) - 1)
  e >>= (-nBits)
  nBits += mLen
  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}

  if (e === 0) {
    e = 1 - eBias
  } else if (e === eMax) {
    return m ? NaN : ((s ? -1 : 1) * Infinity)
  } else {
    m = m + Math.pow(2, mLen)
    e = e - eBias
  }
  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}

exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
  var e, m, c
  var eLen = (nBytes * 8) - mLen - 1
  var eMax = (1 << eLen) - 1
  var eBias = eMax >> 1
  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
  var i = isLE ? 0 : (nBytes - 1)
  var d = isLE ? 1 : -1
  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0

  value = Math.abs(value)

  if (isNaN(value) || value === Infinity) {
    m = isNaN(value) ? 1 : 0
    e = eMax
  } else {
    e = Math.floor(Math.log(value) / Math.LN2)
    if (value * (c = Math.pow(2, -e)) < 1) {
      e--
      c *= 2
    }
    if (e + eBias >= 1) {
      value += rt / c
    } else {
      value += rt * Math.pow(2, 1 - eBias)
    }
    if (value * c >= 2) {
      e++
      c /= 2
    }

    if (e + eBias >= eMax) {
      m = 0
      e = eMax
    } else if (e + eBias >= 1) {
      m = ((value * c) - 1) * Math.pow(2, mLen)
      e = e + eBias
    } else {
      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
      e = 0
    }
  }

  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

  e = (e << mLen) | m
  eLen += mLen
  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

  buffer[offset + i - d] |= s * 128
}


/***/ }),

/***/ 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;
    }
}


/***/ }),

/***/ 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);
};


/***/ }),

/***/ 1908:
/***/ ((module) => {

function webpackEmptyContext(req) {
	var e = new Error("Cannot find module '" + req + "'");
	e.code = 'MODULE_NOT_FOUND';
	throw e;
}
webpackEmptyContext.keys = () => ([]);
webpackEmptyContext.resolve = webpackEmptyContext;
webpackEmptyContext.id = 1908;
module.exports = webpackEmptyContext;

/***/ }),

/***/ 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/amd options */
/******/ 	(() => {
/******/ 		__webpack_require__.amdO = {};
/******/ 	})();
/******/ 	
/******/ 	/* 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__, {
  YamlService: () => (/* binding */ YamlService)
});

// EXTERNAL MODULE: ./src/services/base-service.ts
var base_service = __webpack_require__(2125);
;// CONCATENATED MODULE: ./src/services/yaml/lib/index.js
/* provided dependency */ var process = __webpack_require__(9907);
/* provided dependency */ var console = __webpack_require__(4364);
/* provided dependency */ var Buffer = __webpack_require__(1048)["hp"];
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value1)=>key in obj ? __defProp(obj, key, {
        enumerable: true,
        configurable: true,
        writable: true,
        value: value1
    }) : obj[key] = value1;
var __require = /* @__PURE__ */ ((x)=> true ? __webpack_require__(1908) : 0)(function(x) {
    if (true) return __webpack_require__(1908).apply(this, arguments);
    throw Error('Dynamic require of "' + x + '" is not supported');
});
var __commonJS = (cb, mod)=>function __require2() {
        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
            exports: {}
        }).exports, mod), mod.exports;
    };
var __export = (target, all)=>{
    for(var name in all)__defProp(target, name, {
        get: all[name],
        enumerable: true
    });
};
var __copyProps = (to, from, except, desc)=>{
    if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
            get: ()=>from[key],
            enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
        });
    }
    return to;
};
var __toESM = (mod, isNodeMode, target)=>(target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
        value: mod,
        enumerable: true
    }) : target, mod));
var __publicField = (obj, key, value1)=>{
    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value1);
    return value1;
};
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-types/lib/umd/main.js
var require_main = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-types/lib/umd/main.js" (exports, module) {
        (function(factory) {
            if (typeof module === "object" && typeof module.exports === "object") {
                var v = factory(__require, exports);
                if (v !== void 0) module.exports = v;
            } else if (typeof define === "function" && __webpack_require__.amdO) {
                define([
                    "require",
                    "exports"
                ], factory);
            }
        })(function(require2, exports2) {
            "use strict";
            Object.defineProperty(exports2, "__esModule", {
                value: true
            });
            exports2.TextDocument = exports2.EOL = exports2.SelectionRange = exports2.DocumentLink = exports2.FormattingOptions = exports2.CodeLens = exports2.CodeAction = exports2.CodeActionContext = exports2.CodeActionKind = exports2.DocumentSymbol = exports2.SymbolInformation = exports2.SymbolTag = exports2.SymbolKind = exports2.DocumentHighlight = exports2.DocumentHighlightKind = exports2.SignatureInformation = exports2.ParameterInformation = exports2.Hover = exports2.MarkedString = exports2.CompletionList = exports2.CompletionItem = exports2.InsertTextMode = exports2.InsertReplaceEdit = exports2.CompletionItemTag = exports2.InsertTextFormat = exports2.CompletionItemKind = exports2.MarkupContent = exports2.MarkupKind = exports2.TextDocumentItem = exports2.OptionalVersionedTextDocumentIdentifier = exports2.VersionedTextDocumentIdentifier = exports2.TextDocumentIdentifier = exports2.WorkspaceChange = exports2.WorkspaceEdit = exports2.DeleteFile = exports2.RenameFile = exports2.CreateFile = exports2.TextDocumentEdit = exports2.AnnotatedTextEdit = exports2.ChangeAnnotationIdentifier = exports2.ChangeAnnotation = exports2.TextEdit = exports2.Command = exports2.Diagnostic = exports2.CodeDescription = exports2.DiagnosticTag = exports2.DiagnosticSeverity = exports2.DiagnosticRelatedInformation = exports2.FoldingRange = exports2.FoldingRangeKind = exports2.ColorPresentation = exports2.ColorInformation = exports2.Color = exports2.LocationLink = exports2.Location = exports2.Range = exports2.Position = exports2.uinteger = exports2.integer = void 0;
            var integer;
            (function(integer2) {
                integer2.MIN_VALUE = -2147483648;
                integer2.MAX_VALUE = 2147483647;
            })(integer = exports2.integer || (exports2.integer = {}));
            var uinteger;
            (function(uinteger2) {
                uinteger2.MIN_VALUE = 0;
                uinteger2.MAX_VALUE = 2147483647;
            })(uinteger = exports2.uinteger || (exports2.uinteger = {}));
            var Position7;
            (function(Position8) {
                function create(line, character) {
                    if (line === Number.MAX_VALUE) {
                        line = uinteger.MAX_VALUE;
                    }
                    if (character === Number.MAX_VALUE) {
                        character = uinteger.MAX_VALUE;
                    }
                    return {
                        line,
                        character
                    };
                }
                Position8.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
                }
                Position8.is = is;
            })(Position7 = exports2.Position || (exports2.Position = {}));
            var Range15;
            (function(Range16) {
                function create(one, two, three, four) {
                    if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
                        return {
                            start: Position7.create(one, two),
                            end: Position7.create(three, four)
                        };
                    } else if (Position7.is(one) && Position7.is(two)) {
                        return {
                            start: one,
                            end: two
                        };
                    } else {
                        throw new Error("Range#create called with invalid arguments[" + one + ", " + two + ", " + three + ", " + four + "]");
                    }
                }
                Range16.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.objectLiteral(candidate) && Position7.is(candidate.start) && Position7.is(candidate.end);
                }
                Range16.is = is;
            })(Range15 = exports2.Range || (exports2.Range = {}));
            var Location2;
            (function(Location3) {
                function create(uri, range) {
                    return {
                        uri,
                        range
                    };
                }
                Location3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Range15.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
                }
                Location3.is = is;
            })(Location2 = exports2.Location || (exports2.Location = {}));
            var LocationLink2;
            (function(LocationLink3) {
                function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
                    return {
                        targetUri,
                        targetRange,
                        targetSelectionRange,
                        originSelectionRange
                    };
                }
                LocationLink3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Range15.is(candidate.targetRange) && Is.string(candidate.targetUri) && (Range15.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange)) && (Range15.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
                }
                LocationLink3.is = is;
            })(LocationLink2 = exports2.LocationLink || (exports2.LocationLink = {}));
            var Color2;
            (function(Color3) {
                function create(red, green, blue, alpha) {
                    return {
                        red,
                        green,
                        blue,
                        alpha
                    };
                }
                Color3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
                }
                Color3.is = is;
            })(Color2 = exports2.Color || (exports2.Color = {}));
            var ColorInformation2;
            (function(ColorInformation3) {
                function create(range, color) {
                    return {
                        range,
                        color
                    };
                }
                ColorInformation3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Range15.is(candidate.range) && Color2.is(candidate.color);
                }
                ColorInformation3.is = is;
            })(ColorInformation2 = exports2.ColorInformation || (exports2.ColorInformation = {}));
            var ColorPresentation2;
            (function(ColorPresentation3) {
                function create(label, textEdit, additionalTextEdits) {
                    return {
                        label,
                        textEdit,
                        additionalTextEdits
                    };
                }
                ColorPresentation3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit6.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit6.is));
                }
                ColorPresentation3.is = is;
            })(ColorPresentation2 = exports2.ColorPresentation || (exports2.ColorPresentation = {}));
            var FoldingRangeKind2;
            (function(FoldingRangeKind3) {
                FoldingRangeKind3["Comment"] = "comment";
                FoldingRangeKind3["Imports"] = "imports";
                FoldingRangeKind3["Region"] = "region";
            })(FoldingRangeKind2 = exports2.FoldingRangeKind || (exports2.FoldingRangeKind = {}));
            var FoldingRange3;
            (function(FoldingRange4) {
                function create(startLine, endLine, startCharacter, endCharacter, kind) {
                    var result = {
                        startLine,
                        endLine
                    };
                    if (Is.defined(startCharacter)) {
                        result.startCharacter = startCharacter;
                    }
                    if (Is.defined(endCharacter)) {
                        result.endCharacter = endCharacter;
                    }
                    if (Is.defined(kind)) {
                        result.kind = kind;
                    }
                    return result;
                }
                FoldingRange4.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
                }
                FoldingRange4.is = is;
            })(FoldingRange3 = exports2.FoldingRange || (exports2.FoldingRange = {}));
            var DiagnosticRelatedInformation;
            (function(DiagnosticRelatedInformation2) {
                function create(location, message) {
                    return {
                        location,
                        message
                    };
                }
                DiagnosticRelatedInformation2.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Location2.is(candidate.location) && Is.string(candidate.message);
                }
                DiagnosticRelatedInformation2.is = is;
            })(DiagnosticRelatedInformation = exports2.DiagnosticRelatedInformation || (exports2.DiagnosticRelatedInformation = {}));
            var DiagnosticSeverity6;
            (function(DiagnosticSeverity7) {
                DiagnosticSeverity7.Error = 1;
                DiagnosticSeverity7.Warning = 2;
                DiagnosticSeverity7.Information = 3;
                DiagnosticSeverity7.Hint = 4;
            })(DiagnosticSeverity6 = exports2.DiagnosticSeverity || (exports2.DiagnosticSeverity = {}));
            var DiagnosticTag2;
            (function(DiagnosticTag3) {
                DiagnosticTag3.Unnecessary = 1;
                DiagnosticTag3.Deprecated = 2;
            })(DiagnosticTag2 = exports2.DiagnosticTag || (exports2.DiagnosticTag = {}));
            var CodeDescription;
            (function(CodeDescription2) {
                function is(value1) {
                    var candidate = value1;
                    return candidate !== void 0 && candidate !== null && Is.string(candidate.href);
                }
                CodeDescription2.is = is;
            })(CodeDescription = exports2.CodeDescription || (exports2.CodeDescription = {}));
            var Diagnostic7;
            (function(Diagnostic8) {
                function create(range, message, severity, code, source, relatedInformation) {
                    var result = {
                        range,
                        message
                    };
                    if (Is.defined(severity)) {
                        result.severity = severity;
                    }
                    if (Is.defined(code)) {
                        result.code = code;
                    }
                    if (Is.defined(source)) {
                        result.source = source;
                    }
                    if (Is.defined(relatedInformation)) {
                        result.relatedInformation = relatedInformation;
                    }
                    return result;
                }
                Diagnostic8.create = create;
                function is(value1) {
                    var _a;
                    var candidate = value1;
                    return Is.defined(candidate) && Range15.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));
                }
                Diagnostic8.is = is;
            })(Diagnostic7 = exports2.Diagnostic || (exports2.Diagnostic = {}));
            var Command3;
            (function(Command4) {
                function create(title, command) {
                    var args = [];
                    for(var _i = 2; _i < arguments.length; _i++){
                        args[_i - 2] = arguments[_i];
                    }
                    var result = {
                        title,
                        command
                    };
                    if (Is.defined(args) && args.length > 0) {
                        result.arguments = args;
                    }
                    return result;
                }
                Command4.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
                }
                Command4.is = is;
            })(Command3 = exports2.Command || (exports2.Command = {}));
            var TextEdit6;
            (function(TextEdit7) {
                function replace(range, newText) {
                    return {
                        range,
                        newText
                    };
                }
                TextEdit7.replace = replace;
                function insert(position, newText) {
                    return {
                        range: {
                            start: position,
                            end: position
                        },
                        newText
                    };
                }
                TextEdit7.insert = insert;
                function del(range) {
                    return {
                        range,
                        newText: ""
                    };
                }
                TextEdit7.del = del;
                function is(value1) {
                    var candidate = value1;
                    return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range15.is(candidate.range);
                }
                TextEdit7.is = is;
            })(TextEdit6 = exports2.TextEdit || (exports2.TextEdit = {}));
            var ChangeAnnotation;
            (function(ChangeAnnotation2) {
                function create(label, needsConfirmation, description) {
                    var result = {
                        label
                    };
                    if (needsConfirmation !== void 0) {
                        result.needsConfirmation = needsConfirmation;
                    }
                    if (description !== void 0) {
                        result.description = description;
                    }
                    return result;
                }
                ChangeAnnotation2.create = create;
                function is(value1) {
                    var candidate = value1;
                    return candidate !== void 0 && Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
                }
                ChangeAnnotation2.is = is;
            })(ChangeAnnotation = exports2.ChangeAnnotation || (exports2.ChangeAnnotation = {}));
            var ChangeAnnotationIdentifier;
            (function(ChangeAnnotationIdentifier2) {
                function is(value1) {
                    var candidate = value1;
                    return typeof candidate === "string";
                }
                ChangeAnnotationIdentifier2.is = is;
            })(ChangeAnnotationIdentifier = exports2.ChangeAnnotationIdentifier || (exports2.ChangeAnnotationIdentifier = {}));
            var AnnotatedTextEdit;
            (function(AnnotatedTextEdit2) {
                function replace(range, newText, annotation) {
                    return {
                        range,
                        newText,
                        annotationId: annotation
                    };
                }
                AnnotatedTextEdit2.replace = replace;
                function insert(position, newText, annotation) {
                    return {
                        range: {
                            start: position,
                            end: position
                        },
                        newText,
                        annotationId: annotation
                    };
                }
                AnnotatedTextEdit2.insert = insert;
                function del(range, annotation) {
                    return {
                        range,
                        newText: "",
                        annotationId: annotation
                    };
                }
                AnnotatedTextEdit2.del = del;
                function is(value1) {
                    var candidate = value1;
                    return TextEdit6.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
                }
                AnnotatedTextEdit2.is = is;
            })(AnnotatedTextEdit = exports2.AnnotatedTextEdit || (exports2.AnnotatedTextEdit = {}));
            var TextDocumentEdit2;
            (function(TextDocumentEdit3) {
                function create(textDocument, edits) {
                    return {
                        textDocument,
                        edits
                    };
                }
                TextDocumentEdit3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
                }
                TextDocumentEdit3.is = is;
            })(TextDocumentEdit2 = exports2.TextDocumentEdit || (exports2.TextDocumentEdit = {}));
            var CreateFile;
            (function(CreateFile2) {
                function create(uri, options, annotation) {
                    var result = {
                        kind: "create",
                        uri
                    };
                    if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
                        result.options = options;
                    }
                    if (annotation !== void 0) {
                        result.annotationId = annotation;
                    }
                    return result;
                }
                CreateFile2.create = create;
                function is(value1) {
                    var candidate = value1;
                    return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
                }
                CreateFile2.is = is;
            })(CreateFile = exports2.CreateFile || (exports2.CreateFile = {}));
            var RenameFile;
            (function(RenameFile2) {
                function create(oldUri, newUri, options, annotation) {
                    var result = {
                        kind: "rename",
                        oldUri,
                        newUri
                    };
                    if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
                        result.options = options;
                    }
                    if (annotation !== void 0) {
                        result.annotationId = annotation;
                    }
                    return result;
                }
                RenameFile2.create = create;
                function is(value1) {
                    var candidate = value1;
                    return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
                }
                RenameFile2.is = is;
            })(RenameFile = exports2.RenameFile || (exports2.RenameFile = {}));
            var DeleteFile;
            (function(DeleteFile2) {
                function create(uri, options, annotation) {
                    var result = {
                        kind: "delete",
                        uri
                    };
                    if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
                        result.options = options;
                    }
                    if (annotation !== void 0) {
                        result.annotationId = annotation;
                    }
                    return result;
                }
                DeleteFile2.create = create;
                function is(value1) {
                    var candidate = value1;
                    return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
                }
                DeleteFile2.is = is;
            })(DeleteFile = exports2.DeleteFile || (exports2.DeleteFile = {}));
            var WorkspaceEdit2;
            (function(WorkspaceEdit3) {
                function is(value1) {
                    var candidate = value1;
                    return candidate && (candidate.changes !== void 0 || candidate.documentChanges !== void 0) && (candidate.documentChanges === void 0 || candidate.documentChanges.every(function(change) {
                        if (Is.string(change.kind)) {
                            return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);
                        } else {
                            return TextDocumentEdit2.is(change);
                        }
                    }));
                }
                WorkspaceEdit3.is = is;
            })(WorkspaceEdit2 = exports2.WorkspaceEdit || (exports2.WorkspaceEdit = {}));
            var TextEditChangeImpl = /** @class */ function() {
                function TextEditChangeImpl2(edits, changeAnnotations) {
                    this.edits = edits;
                    this.changeAnnotations = changeAnnotations;
                }
                TextEditChangeImpl2.prototype.insert = function(position, newText, annotation) {
                    var edit;
                    var id;
                    if (annotation === void 0) {
                        edit = TextEdit6.insert(position, newText);
                    } else if (ChangeAnnotationIdentifier.is(annotation)) {
                        id = annotation;
                        edit = AnnotatedTextEdit.insert(position, newText, annotation);
                    } else {
                        this.assertChangeAnnotations(this.changeAnnotations);
                        id = this.changeAnnotations.manage(annotation);
                        edit = AnnotatedTextEdit.insert(position, newText, id);
                    }
                    this.edits.push(edit);
                    if (id !== void 0) {
                        return id;
                    }
                };
                TextEditChangeImpl2.prototype.replace = function(range, newText, annotation) {
                    var edit;
                    var id;
                    if (annotation === void 0) {
                        edit = TextEdit6.replace(range, newText);
                    } else if (ChangeAnnotationIdentifier.is(annotation)) {
                        id = annotation;
                        edit = AnnotatedTextEdit.replace(range, newText, annotation);
                    } else {
                        this.assertChangeAnnotations(this.changeAnnotations);
                        id = this.changeAnnotations.manage(annotation);
                        edit = AnnotatedTextEdit.replace(range, newText, id);
                    }
                    this.edits.push(edit);
                    if (id !== void 0) {
                        return id;
                    }
                };
                TextEditChangeImpl2.prototype.delete = function(range, annotation) {
                    var edit;
                    var id;
                    if (annotation === void 0) {
                        edit = TextEdit6.del(range);
                    } else if (ChangeAnnotationIdentifier.is(annotation)) {
                        id = annotation;
                        edit = AnnotatedTextEdit.del(range, annotation);
                    } else {
                        this.assertChangeAnnotations(this.changeAnnotations);
                        id = this.changeAnnotations.manage(annotation);
                        edit = AnnotatedTextEdit.del(range, id);
                    }
                    this.edits.push(edit);
                    if (id !== void 0) {
                        return id;
                    }
                };
                TextEditChangeImpl2.prototype.add = function(edit) {
                    this.edits.push(edit);
                };
                TextEditChangeImpl2.prototype.all = function() {
                    return this.edits;
                };
                TextEditChangeImpl2.prototype.clear = function() {
                    this.edits.splice(0, this.edits.length);
                };
                TextEditChangeImpl2.prototype.assertChangeAnnotations = function(value1) {
                    if (value1 === void 0) {
                        throw new Error("Text edit change is not configured to manage change annotations.");
                    }
                };
                return TextEditChangeImpl2;
            }();
            var ChangeAnnotations = /** @class */ function() {
                function ChangeAnnotations2(annotations) {
                    this._annotations = annotations === void 0 ? /* @__PURE__ */ Object.create(null) : annotations;
                    this._counter = 0;
                    this._size = 0;
                }
                ChangeAnnotations2.prototype.all = function() {
                    return this._annotations;
                };
                Object.defineProperty(ChangeAnnotations2.prototype, "size", {
                    get: function() {
                        return this._size;
                    },
                    enumerable: false,
                    configurable: true
                });
                ChangeAnnotations2.prototype.manage = function(idOrAnnotation, annotation) {
                    var id;
                    if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
                        id = idOrAnnotation;
                    } else {
                        id = this.nextId();
                        annotation = idOrAnnotation;
                    }
                    if (this._annotations[id] !== void 0) {
                        throw new Error("Id " + id + " is already in use.");
                    }
                    if (annotation === void 0) {
                        throw new Error("No annotation provided for id " + id);
                    }
                    this._annotations[id] = annotation;
                    this._size++;
                    return id;
                };
                ChangeAnnotations2.prototype.nextId = function() {
                    this._counter++;
                    return this._counter.toString();
                };
                return ChangeAnnotations2;
            }();
            var WorkspaceChange = /** @class */ function() {
                function WorkspaceChange2(workspaceEdit) {
                    var _this = this;
                    this._textEditChanges = /* @__PURE__ */ Object.create(null);
                    if (workspaceEdit !== void 0) {
                        this._workspaceEdit = workspaceEdit;
                        if (workspaceEdit.documentChanges) {
                            this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);
                            workspaceEdit.changeAnnotations = this._changeAnnotations.all();
                            workspaceEdit.documentChanges.forEach(function(change) {
                                if (TextDocumentEdit2.is(change)) {
                                    var textEditChange = new TextEditChangeImpl(change.edits, _this._changeAnnotations);
                                    _this._textEditChanges[change.textDocument.uri] = textEditChange;
                                }
                            });
                        } else if (workspaceEdit.changes) {
                            Object.keys(workspaceEdit.changes).forEach(function(key) {
                                var textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);
                                _this._textEditChanges[key] = textEditChange;
                            });
                        }
                    } else {
                        this._workspaceEdit = {};
                    }
                }
                Object.defineProperty(WorkspaceChange2.prototype, "edit", {
                    /**
             * Returns the underlying [WorkspaceEdit](#WorkspaceEdit) literal
             * use to be returned from a workspace edit operation like rename.
             */ get: function() {
                        this.initDocumentChanges();
                        if (this._changeAnnotations !== void 0) {
                            if (this._changeAnnotations.size === 0) {
                                this._workspaceEdit.changeAnnotations = void 0;
                            } else {
                                this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
                            }
                        }
                        return this._workspaceEdit;
                    },
                    enumerable: false,
                    configurable: true
                });
                WorkspaceChange2.prototype.getTextEditChange = function(key) {
                    if (OptionalVersionedTextDocumentIdentifier.is(key)) {
                        this.initDocumentChanges();
                        if (this._workspaceEdit.documentChanges === void 0) {
                            throw new Error("Workspace edit is not configured for document changes.");
                        }
                        var textDocument = {
                            uri: key.uri,
                            version: key.version
                        };
                        var result = this._textEditChanges[textDocument.uri];
                        if (!result) {
                            var edits = [];
                            var textDocumentEdit = {
                                textDocument,
                                edits
                            };
                            this._workspaceEdit.documentChanges.push(textDocumentEdit);
                            result = new TextEditChangeImpl(edits, this._changeAnnotations);
                            this._textEditChanges[textDocument.uri] = result;
                        }
                        return result;
                    } else {
                        this.initChanges();
                        if (this._workspaceEdit.changes === void 0) {
                            throw new Error("Workspace edit is not configured for normal text edit changes.");
                        }
                        var result = this._textEditChanges[key];
                        if (!result) {
                            var edits = [];
                            this._workspaceEdit.changes[key] = edits;
                            result = new TextEditChangeImpl(edits);
                            this._textEditChanges[key] = result;
                        }
                        return result;
                    }
                };
                WorkspaceChange2.prototype.initDocumentChanges = function() {
                    if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
                        this._changeAnnotations = new ChangeAnnotations();
                        this._workspaceEdit.documentChanges = [];
                        this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
                    }
                };
                WorkspaceChange2.prototype.initChanges = function() {
                    if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
                        this._workspaceEdit.changes = /* @__PURE__ */ Object.create(null);
                    }
                };
                WorkspaceChange2.prototype.createFile = function(uri, optionsOrAnnotation, options) {
                    this.initDocumentChanges();
                    if (this._workspaceEdit.documentChanges === void 0) {
                        throw new Error("Workspace edit is not configured for document changes.");
                    }
                    var annotation;
                    if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
                        annotation = optionsOrAnnotation;
                    } else {
                        options = optionsOrAnnotation;
                    }
                    var operation;
                    var id;
                    if (annotation === void 0) {
                        operation = CreateFile.create(uri, options);
                    } else {
                        id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
                        operation = CreateFile.create(uri, options, id);
                    }
                    this._workspaceEdit.documentChanges.push(operation);
                    if (id !== void 0) {
                        return id;
                    }
                };
                WorkspaceChange2.prototype.renameFile = function(oldUri, newUri, optionsOrAnnotation, options) {
                    this.initDocumentChanges();
                    if (this._workspaceEdit.documentChanges === void 0) {
                        throw new Error("Workspace edit is not configured for document changes.");
                    }
                    var annotation;
                    if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
                        annotation = optionsOrAnnotation;
                    } else {
                        options = optionsOrAnnotation;
                    }
                    var operation;
                    var id;
                    if (annotation === void 0) {
                        operation = RenameFile.create(oldUri, newUri, options);
                    } else {
                        id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
                        operation = RenameFile.create(oldUri, newUri, options, id);
                    }
                    this._workspaceEdit.documentChanges.push(operation);
                    if (id !== void 0) {
                        return id;
                    }
                };
                WorkspaceChange2.prototype.deleteFile = function(uri, optionsOrAnnotation, options) {
                    this.initDocumentChanges();
                    if (this._workspaceEdit.documentChanges === void 0) {
                        throw new Error("Workspace edit is not configured for document changes.");
                    }
                    var annotation;
                    if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
                        annotation = optionsOrAnnotation;
                    } else {
                        options = optionsOrAnnotation;
                    }
                    var operation;
                    var id;
                    if (annotation === void 0) {
                        operation = DeleteFile.create(uri, options);
                    } else {
                        id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
                        operation = DeleteFile.create(uri, options, id);
                    }
                    this._workspaceEdit.documentChanges.push(operation);
                    if (id !== void 0) {
                        return id;
                    }
                };
                return WorkspaceChange2;
            }();
            exports2.WorkspaceChange = WorkspaceChange;
            var TextDocumentIdentifier;
            (function(TextDocumentIdentifier2) {
                function create(uri) {
                    return {
                        uri
                    };
                }
                TextDocumentIdentifier2.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Is.string(candidate.uri);
                }
                TextDocumentIdentifier2.is = is;
            })(TextDocumentIdentifier = exports2.TextDocumentIdentifier || (exports2.TextDocumentIdentifier = {}));
            var VersionedTextDocumentIdentifier2;
            (function(VersionedTextDocumentIdentifier3) {
                function create(uri, version) {
                    return {
                        uri,
                        version
                    };
                }
                VersionedTextDocumentIdentifier3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
                }
                VersionedTextDocumentIdentifier3.is = is;
            })(VersionedTextDocumentIdentifier2 = exports2.VersionedTextDocumentIdentifier || (exports2.VersionedTextDocumentIdentifier = {}));
            var OptionalVersionedTextDocumentIdentifier;
            (function(OptionalVersionedTextDocumentIdentifier2) {
                function create(uri, version) {
                    return {
                        uri,
                        version
                    };
                }
                OptionalVersionedTextDocumentIdentifier2.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
                }
                OptionalVersionedTextDocumentIdentifier2.is = is;
            })(OptionalVersionedTextDocumentIdentifier = exports2.OptionalVersionedTextDocumentIdentifier || (exports2.OptionalVersionedTextDocumentIdentifier = {}));
            var TextDocumentItem;
            (function(TextDocumentItem2) {
                function create(uri, languageId, version, text) {
                    return {
                        uri,
                        languageId,
                        version,
                        text
                    };
                }
                TextDocumentItem2.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
                }
                TextDocumentItem2.is = is;
            })(TextDocumentItem = exports2.TextDocumentItem || (exports2.TextDocumentItem = {}));
            var MarkupKind4;
            (function(MarkupKind5) {
                MarkupKind5.PlainText = "plaintext";
                MarkupKind5.Markdown = "markdown";
            })(MarkupKind4 = exports2.MarkupKind || (exports2.MarkupKind = {}));
            (function(MarkupKind5) {
                function is(value1) {
                    var candidate = value1;
                    return candidate === MarkupKind5.PlainText || candidate === MarkupKind5.Markdown;
                }
                MarkupKind5.is = is;
            })(MarkupKind4 = exports2.MarkupKind || (exports2.MarkupKind = {}));
            var MarkupContent2;
            (function(MarkupContent3) {
                function is(value1) {
                    var candidate = value1;
                    return Is.objectLiteral(value1) && MarkupKind4.is(candidate.kind) && Is.string(candidate.value);
                }
                MarkupContent3.is = is;
            })(MarkupContent2 = exports2.MarkupContent || (exports2.MarkupContent = {}));
            var CompletionItemKind3;
            (function(CompletionItemKind4) {
                CompletionItemKind4.Text = 1;
                CompletionItemKind4.Method = 2;
                CompletionItemKind4.Function = 3;
                CompletionItemKind4.Constructor = 4;
                CompletionItemKind4.Field = 5;
                CompletionItemKind4.Variable = 6;
                CompletionItemKind4.Class = 7;
                CompletionItemKind4.Interface = 8;
                CompletionItemKind4.Module = 9;
                CompletionItemKind4.Property = 10;
                CompletionItemKind4.Unit = 11;
                CompletionItemKind4.Value = 12;
                CompletionItemKind4.Enum = 13;
                CompletionItemKind4.Keyword = 14;
                CompletionItemKind4.Snippet = 15;
                CompletionItemKind4.Color = 16;
                CompletionItemKind4.File = 17;
                CompletionItemKind4.Reference = 18;
                CompletionItemKind4.Folder = 19;
                CompletionItemKind4.EnumMember = 20;
                CompletionItemKind4.Constant = 21;
                CompletionItemKind4.Struct = 22;
                CompletionItemKind4.Event = 23;
                CompletionItemKind4.Operator = 24;
                CompletionItemKind4.TypeParameter = 25;
            })(CompletionItemKind3 = exports2.CompletionItemKind || (exports2.CompletionItemKind = {}));
            var InsertTextFormat3;
            (function(InsertTextFormat4) {
                InsertTextFormat4.PlainText = 1;
                InsertTextFormat4.Snippet = 2;
            })(InsertTextFormat3 = exports2.InsertTextFormat || (exports2.InsertTextFormat = {}));
            var CompletionItemTag2;
            (function(CompletionItemTag3) {
                CompletionItemTag3.Deprecated = 1;
            })(CompletionItemTag2 = exports2.CompletionItemTag || (exports2.CompletionItemTag = {}));
            var InsertReplaceEdit;
            (function(InsertReplaceEdit2) {
                function create(newText, insert, replace) {
                    return {
                        newText,
                        insert,
                        replace
                    };
                }
                InsertReplaceEdit2.create = create;
                function is(value1) {
                    var candidate = value1;
                    return candidate && Is.string(candidate.newText) && Range15.is(candidate.insert) && Range15.is(candidate.replace);
                }
                InsertReplaceEdit2.is = is;
            })(InsertReplaceEdit = exports2.InsertReplaceEdit || (exports2.InsertReplaceEdit = {}));
            var InsertTextMode2;
            (function(InsertTextMode3) {
                InsertTextMode3.asIs = 1;
                InsertTextMode3.adjustIndentation = 2;
            })(InsertTextMode2 = exports2.InsertTextMode || (exports2.InsertTextMode = {}));
            var CompletionItem2;
            (function(CompletionItem3) {
                function create(label) {
                    return {
                        label
                    };
                }
                CompletionItem3.create = create;
            })(CompletionItem2 = exports2.CompletionItem || (exports2.CompletionItem = {}));
            var CompletionList3;
            (function(CompletionList4) {
                function create(items, isIncomplete) {
                    return {
                        items: items ? items : [],
                        isIncomplete: !!isIncomplete
                    };
                }
                CompletionList4.create = create;
            })(CompletionList3 = exports2.CompletionList || (exports2.CompletionList = {}));
            var MarkedString2;
            (function(MarkedString3) {
                function fromPlainText(plainText) {
                    return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
                }
                MarkedString3.fromPlainText = fromPlainText;
                function is(value1) {
                    var candidate = value1;
                    return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
                }
                MarkedString3.is = is;
            })(MarkedString2 = exports2.MarkedString || (exports2.MarkedString = {}));
            var Hover2;
            (function(Hover3) {
                function is(value1) {
                    var candidate = value1;
                    return !!candidate && Is.objectLiteral(candidate) && (MarkupContent2.is(candidate.contents) || MarkedString2.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString2.is)) && (value1.range === void 0 || Range15.is(value1.range));
                }
                Hover3.is = is;
            })(Hover2 = exports2.Hover || (exports2.Hover = {}));
            var ParameterInformation;
            (function(ParameterInformation2) {
                function create(label, documentation) {
                    return documentation ? {
                        label,
                        documentation
                    } : {
                        label
                    };
                }
                ParameterInformation2.create = create;
            })(ParameterInformation = exports2.ParameterInformation || (exports2.ParameterInformation = {}));
            var SignatureInformation;
            (function(SignatureInformation2) {
                function create(label, documentation) {
                    var parameters = [];
                    for(var _i = 2; _i < arguments.length; _i++){
                        parameters[_i - 2] = arguments[_i];
                    }
                    var result = {
                        label
                    };
                    if (Is.defined(documentation)) {
                        result.documentation = documentation;
                    }
                    if (Is.defined(parameters)) {
                        result.parameters = parameters;
                    } else {
                        result.parameters = [];
                    }
                    return result;
                }
                SignatureInformation2.create = create;
            })(SignatureInformation = exports2.SignatureInformation || (exports2.SignatureInformation = {}));
            var DocumentHighlightKind2;
            (function(DocumentHighlightKind3) {
                DocumentHighlightKind3.Text = 1;
                DocumentHighlightKind3.Read = 2;
                DocumentHighlightKind3.Write = 3;
            })(DocumentHighlightKind2 = exports2.DocumentHighlightKind || (exports2.DocumentHighlightKind = {}));
            var DocumentHighlight2;
            (function(DocumentHighlight3) {
                function create(range, kind) {
                    var result = {
                        range
                    };
                    if (Is.number(kind)) {
                        result.kind = kind;
                    }
                    return result;
                }
                DocumentHighlight3.create = create;
            })(DocumentHighlight2 = exports2.DocumentHighlight || (exports2.DocumentHighlight = {}));
            var SymbolKind2;
            (function(SymbolKind3) {
                SymbolKind3.File = 1;
                SymbolKind3.Module = 2;
                SymbolKind3.Namespace = 3;
                SymbolKind3.Package = 4;
                SymbolKind3.Class = 5;
                SymbolKind3.Method = 6;
                SymbolKind3.Property = 7;
                SymbolKind3.Field = 8;
                SymbolKind3.Constructor = 9;
                SymbolKind3.Enum = 10;
                SymbolKind3.Interface = 11;
                SymbolKind3.Function = 12;
                SymbolKind3.Variable = 13;
                SymbolKind3.Constant = 14;
                SymbolKind3.String = 15;
                SymbolKind3.Number = 16;
                SymbolKind3.Boolean = 17;
                SymbolKind3.Array = 18;
                SymbolKind3.Object = 19;
                SymbolKind3.Key = 20;
                SymbolKind3.Null = 21;
                SymbolKind3.EnumMember = 22;
                SymbolKind3.Struct = 23;
                SymbolKind3.Event = 24;
                SymbolKind3.Operator = 25;
                SymbolKind3.TypeParameter = 26;
            })(SymbolKind2 = exports2.SymbolKind || (exports2.SymbolKind = {}));
            var SymbolTag;
            (function(SymbolTag2) {
                SymbolTag2.Deprecated = 1;
            })(SymbolTag = exports2.SymbolTag || (exports2.SymbolTag = {}));
            var SymbolInformation2;
            (function(SymbolInformation3) {
                function create(name, kind, range, uri, containerName) {
                    var result = {
                        name,
                        kind,
                        location: {
                            uri,
                            range
                        }
                    };
                    if (containerName) {
                        result.containerName = containerName;
                    }
                    return result;
                }
                SymbolInformation3.create = create;
            })(SymbolInformation2 = exports2.SymbolInformation || (exports2.SymbolInformation = {}));
            var DocumentSymbol2;
            (function(DocumentSymbol3) {
                function create(name, detail, kind, range, selectionRange, children) {
                    var result = {
                        name,
                        detail,
                        kind,
                        range,
                        selectionRange
                    };
                    if (children !== void 0) {
                        result.children = children;
                    }
                    return result;
                }
                DocumentSymbol3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range15.is(candidate.range) && Range15.is(candidate.selectionRange) && (candidate.detail === void 0 || Is.string(candidate.detail)) && (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children)) && (candidate.tags === void 0 || Array.isArray(candidate.tags));
                }
                DocumentSymbol3.is = is;
            })(DocumentSymbol2 = exports2.DocumentSymbol || (exports2.DocumentSymbol = {}));
            var CodeActionKind3;
            (function(CodeActionKind4) {
                CodeActionKind4.Empty = "";
                CodeActionKind4.QuickFix = "quickfix";
                CodeActionKind4.Refactor = "refactor";
                CodeActionKind4.RefactorExtract = "refactor.extract";
                CodeActionKind4.RefactorInline = "refactor.inline";
                CodeActionKind4.RefactorRewrite = "refactor.rewrite";
                CodeActionKind4.Source = "source";
                CodeActionKind4.SourceOrganizeImports = "source.organizeImports";
                CodeActionKind4.SourceFixAll = "source.fixAll";
            })(CodeActionKind3 = exports2.CodeActionKind || (exports2.CodeActionKind = {}));
            var CodeActionContext2;
            (function(CodeActionContext3) {
                function create(diagnostics, only) {
                    var result = {
                        diagnostics
                    };
                    if (only !== void 0 && only !== null) {
                        result.only = only;
                    }
                    return result;
                }
                CodeActionContext3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic7.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string));
                }
                CodeActionContext3.is = is;
            })(CodeActionContext2 = exports2.CodeActionContext || (exports2.CodeActionContext = {}));
            var CodeAction3;
            (function(CodeAction4) {
                function create(title, kindOrCommandOrEdit, kind) {
                    var result = {
                        title
                    };
                    var checkKind = true;
                    if (typeof kindOrCommandOrEdit === "string") {
                        checkKind = false;
                        result.kind = kindOrCommandOrEdit;
                    } else if (Command3.is(kindOrCommandOrEdit)) {
                        result.command = kindOrCommandOrEdit;
                    } else {
                        result.edit = kindOrCommandOrEdit;
                    }
                    if (checkKind && kind !== void 0) {
                        result.kind = kind;
                    }
                    return result;
                }
                CodeAction4.create = create;
                function is(value1) {
                    var candidate = value1;
                    return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic7.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command3.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit2.is(candidate.edit));
                }
                CodeAction4.is = is;
            })(CodeAction3 = exports2.CodeAction || (exports2.CodeAction = {}));
            var CodeLens2;
            (function(CodeLens3) {
                function create(range, data) {
                    var result = {
                        range
                    };
                    if (Is.defined(data)) {
                        result.data = data;
                    }
                    return result;
                }
                CodeLens3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Range15.is(candidate.range) && (Is.undefined(candidate.command) || Command3.is(candidate.command));
                }
                CodeLens3.is = is;
            })(CodeLens2 = exports2.CodeLens || (exports2.CodeLens = {}));
            var FormattingOptions;
            (function(FormattingOptions2) {
                function create(tabSize, insertSpaces) {
                    return {
                        tabSize,
                        insertSpaces
                    };
                }
                FormattingOptions2.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
                }
                FormattingOptions2.is = is;
            })(FormattingOptions = exports2.FormattingOptions || (exports2.FormattingOptions = {}));
            var DocumentLink2;
            (function(DocumentLink3) {
                function create(range, target, data) {
                    return {
                        range,
                        target,
                        data
                    };
                }
                DocumentLink3.create = create;
                function is(value1) {
                    var candidate = value1;
                    return Is.defined(candidate) && Range15.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
                }
                DocumentLink3.is = is;
            })(DocumentLink2 = exports2.DocumentLink || (exports2.DocumentLink = {}));
            var SelectionRange3;
            (function(SelectionRange4) {
                function create(range, parent) {
                    return {
                        range,
                        parent
                    };
                }
                SelectionRange4.create = create;
                function is(value1) {
                    var candidate = value1;
                    return candidate !== void 0 && Range15.is(candidate.range) && (candidate.parent === void 0 || SelectionRange4.is(candidate.parent));
                }
                SelectionRange4.is = is;
            })(SelectionRange3 = exports2.SelectionRange || (exports2.SelectionRange = {}));
            exports2.EOL = [
                "\n",
                "\r\n",
                "\r"
            ];
            var TextDocument2;
            (function(TextDocument3) {
                function create(uri, languageId, version, content) {
                    return new FullTextDocument2(uri, languageId, version, content);
                }
                TextDocument3.create = create;
                function is(value1) {
                    var candidate = value1;
                    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;
                }
                TextDocument3.is = is;
                function applyEdits(document2, edits) {
                    var text = document2.getText();
                    var sortedEdits = mergeSort2(edits, function(a2, b) {
                        var diff = a2.range.start.line - b.range.start.line;
                        if (diff === 0) {
                            return a2.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 = document2.offsetAt(e.range.start);
                        var endOffset = document2.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;
                }
                TextDocument3.applyEdits = applyEdits;
                function mergeSort2(data, compare2) {
                    if (data.length <= 1) {
                        return data;
                    }
                    var p = data.length / 2 | 0;
                    var left = data.slice(0, p);
                    var right = data.slice(p);
                    mergeSort2(left, compare2);
                    mergeSort2(right, compare2);
                    var leftIdx = 0;
                    var rightIdx = 0;
                    var i = 0;
                    while(leftIdx < left.length && rightIdx < right.length){
                        var ret = compare2(left[leftIdx], right[rightIdx]);
                        if (ret <= 0) {
                            data[i++] = left[leftIdx++];
                        } else {
                            data[i++] = right[rightIdx++];
                        }
                    }
                    while(leftIdx < left.length){
                        data[i++] = left[leftIdx++];
                    }
                    while(rightIdx < right.length){
                        data[i++] = right[rightIdx++];
                    }
                    return data;
                }
            })(TextDocument2 = exports2.TextDocument || (exports2.TextDocument = {}));
            var FullTextDocument2 = /** @class */ function() {
                function FullTextDocument3(uri, languageId, version, content) {
                    this._uri = uri;
                    this._languageId = languageId;
                    this._version = version;
                    this._content = content;
                    this._lineOffsets = void 0;
                }
                Object.defineProperty(FullTextDocument3.prototype, "uri", {
                    get: function() {
                        return this._uri;
                    },
                    enumerable: false,
                    configurable: true
                });
                Object.defineProperty(FullTextDocument3.prototype, "languageId", {
                    get: function() {
                        return this._languageId;
                    },
                    enumerable: false,
                    configurable: true
                });
                Object.defineProperty(FullTextDocument3.prototype, "version", {
                    get: function() {
                        return this._version;
                    },
                    enumerable: false,
                    configurable: true
                });
                FullTextDocument3.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;
                };
                FullTextDocument3.prototype.update = function(event, version) {
                    this._content = event.text;
                    this._version = version;
                    this._lineOffsets = void 0;
                };
                FullTextDocument3.prototype.getLineOffsets = function() {
                    if (this._lineOffsets === void 0) {
                        var lineOffsets = [];
                        var text = this._content;
                        var isLineStart = true;
                        for(var i = 0; i < text.length; i++){
                            if (isLineStart) {
                                lineOffsets.push(i);
                                isLineStart = false;
                            }
                            var ch = text.charAt(i);
                            isLineStart = ch === "\r" || ch === "\n";
                            if (ch === "\r" && i + 1 < text.length && text.charAt(i + 1) === "\n") {
                                i++;
                            }
                        }
                        if (isLineStart && text.length > 0) {
                            lineOffsets.push(text.length);
                        }
                        this._lineOffsets = lineOffsets;
                    }
                    return this._lineOffsets;
                };
                FullTextDocument3.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 Position7.create(0, offset);
                    }
                    while(low < high){
                        var mid = Math.floor((low + high) / 2);
                        if (lineOffsets[mid] > offset) {
                            high = mid;
                        } else {
                            low = mid + 1;
                        }
                    }
                    var line = low - 1;
                    return Position7.create(line, offset - lineOffsets[line]);
                };
                FullTextDocument3.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(FullTextDocument3.prototype, "lineCount", {
                    get: function() {
                        return this.getLineOffsets().length;
                    },
                    enumerable: false,
                    configurable: true
                });
                return FullTextDocument3;
            }();
            var Is;
            (function(Is2) {
                var toString = Object.prototype.toString;
                function defined(value1) {
                    return typeof value1 !== "undefined";
                }
                Is2.defined = defined;
                function undefined2(value1) {
                    return typeof value1 === "undefined";
                }
                Is2.undefined = undefined2;
                function boolean(value1) {
                    return value1 === true || value1 === false;
                }
                Is2.boolean = boolean;
                function string2(value1) {
                    return toString.call(value1) === "[object String]";
                }
                Is2.string = string2;
                function number(value1) {
                    return toString.call(value1) === "[object Number]";
                }
                Is2.number = number;
                function numberRange(value1, min, max) {
                    return toString.call(value1) === "[object Number]" && min <= value1 && value1 <= max;
                }
                Is2.numberRange = numberRange;
                function integer2(value1) {
                    return toString.call(value1) === "[object Number]" && -2147483648 <= value1 && value1 <= 2147483647;
                }
                Is2.integer = integer2;
                function uinteger2(value1) {
                    return toString.call(value1) === "[object Number]" && 0 <= value1 && value1 <= 2147483647;
                }
                Is2.uinteger = uinteger2;
                function func(value1) {
                    return toString.call(value1) === "[object Function]";
                }
                Is2.func = func;
                function objectLiteral(value1) {
                    return value1 !== null && typeof value1 === "object";
                }
                Is2.objectLiteral = objectLiteral;
                function typedArray(value1, check) {
                    return Array.isArray(value1) && value1.every(check);
                }
                Is2.typedArray = typedArray;
            })(Is || (Is = {}));
        });
    }
});
// ../../node_modules/path-browserify/index.js
var require_path_browserify = __commonJS({
    "../../node_modules/path-browserify/index.js" (exports, module) {
        "use strict";
        function assertPath(path5) {
            if (typeof path5 !== "string") {
                throw new TypeError("Path must be a string. Received " + JSON.stringify(path5));
            }
        }
        function normalizeStringPosix(path5, allowAboveRoot) {
            var res = "";
            var lastSegmentLength = 0;
            var lastSlash = -1;
            var dots = 0;
            var code;
            for(var i = 0; i <= path5.length; ++i){
                if (i < path5.length) code = path5.charCodeAt(i);
                else if (code === 47) break;
                else code = 47;
                if (code === 47) {
                    if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) {
                        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
                            if (res.length > 2) {
                                var lastSlashIndex = res.lastIndexOf("/");
                                if (lastSlashIndex !== res.length - 1) {
                                    if (lastSlashIndex === -1) {
                                        res = "";
                                        lastSegmentLength = 0;
                                    } else {
                                        res = res.slice(0, lastSlashIndex);
                                        lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
                                    }
                                    lastSlash = i;
                                    dots = 0;
                                    continue;
                                }
                            } else if (res.length === 2 || res.length === 1) {
                                res = "";
                                lastSegmentLength = 0;
                                lastSlash = i;
                                dots = 0;
                                continue;
                            }
                        }
                        if (allowAboveRoot) {
                            if (res.length > 0) res += "/..";
                            else res = "..";
                            lastSegmentLength = 2;
                        }
                    } else {
                        if (res.length > 0) res += "/" + path5.slice(lastSlash + 1, i);
                        else res = path5.slice(lastSlash + 1, i);
                        lastSegmentLength = i - lastSlash - 1;
                    }
                    lastSlash = i;
                    dots = 0;
                } else if (code === 46 && dots !== -1) {
                    ++dots;
                } else {
                    dots = -1;
                }
            }
            return res;
        }
        function _format(sep, pathObject) {
            var dir = pathObject.dir || pathObject.root;
            var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
            if (!dir) {
                return base;
            }
            if (dir === pathObject.root) {
                return dir + base;
            }
            return dir + sep + base;
        }
        var posix = {
            // path.resolve([from ...], to)
            resolve: function resolve2() {
                var resolvedPath = "";
                var resolvedAbsolute = false;
                var cwd;
                for(var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--){
                    var path5;
                    if (i >= 0) path5 = arguments[i];
                    else {
                        if (cwd === void 0) cwd = process.cwd();
                        path5 = cwd;
                    }
                    assertPath(path5);
                    if (path5.length === 0) {
                        continue;
                    }
                    resolvedPath = path5 + "/" + resolvedPath;
                    resolvedAbsolute = path5.charCodeAt(0) === 47;
                }
                resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
                if (resolvedAbsolute) {
                    if (resolvedPath.length > 0) return "/" + resolvedPath;
                    else return "/";
                } else if (resolvedPath.length > 0) {
                    return resolvedPath;
                } else {
                    return ".";
                }
            },
            normalize: function normalize(path5) {
                assertPath(path5);
                if (path5.length === 0) return ".";
                var isAbsolute2 = path5.charCodeAt(0) === 47;
                var trailingSeparator = path5.charCodeAt(path5.length - 1) === 47;
                path5 = normalizeStringPosix(path5, !isAbsolute2);
                if (path5.length === 0 && !isAbsolute2) path5 = ".";
                if (path5.length > 0 && trailingSeparator) path5 += "/";
                if (isAbsolute2) return "/" + path5;
                return path5;
            },
            isAbsolute: function isAbsolute2(path5) {
                assertPath(path5);
                return path5.length > 0 && path5.charCodeAt(0) === 47;
            },
            join: function join() {
                if (arguments.length === 0) return ".";
                var joined;
                for(var i = 0; i < arguments.length; ++i){
                    var arg = arguments[i];
                    assertPath(arg);
                    if (arg.length > 0) {
                        if (joined === void 0) joined = arg;
                        else joined += "/" + arg;
                    }
                }
                if (joined === void 0) return ".";
                return posix.normalize(joined);
            },
            relative: function relative(from, to) {
                assertPath(from);
                assertPath(to);
                if (from === to) return "";
                from = posix.resolve(from);
                to = posix.resolve(to);
                if (from === to) return "";
                var fromStart = 1;
                for(; fromStart < from.length; ++fromStart){
                    if (from.charCodeAt(fromStart) !== 47) break;
                }
                var fromEnd = from.length;
                var fromLen = fromEnd - fromStart;
                var toStart = 1;
                for(; toStart < to.length; ++toStart){
                    if (to.charCodeAt(toStart) !== 47) break;
                }
                var toEnd = to.length;
                var toLen = toEnd - toStart;
                var length = fromLen < toLen ? fromLen : toLen;
                var lastCommonSep = -1;
                var i = 0;
                for(; i <= length; ++i){
                    if (i === length) {
                        if (toLen > length) {
                            if (to.charCodeAt(toStart + i) === 47) {
                                return to.slice(toStart + i + 1);
                            } else if (i === 0) {
                                return to.slice(toStart + i);
                            }
                        } else if (fromLen > length) {
                            if (from.charCodeAt(fromStart + i) === 47) {
                                lastCommonSep = i;
                            } else if (i === 0) {
                                lastCommonSep = 0;
                            }
                        }
                        break;
                    }
                    var fromCode = from.charCodeAt(fromStart + i);
                    var toCode = to.charCodeAt(toStart + i);
                    if (fromCode !== toCode) break;
                    else if (fromCode === 47) lastCommonSep = i;
                }
                var out = "";
                for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){
                    if (i === fromEnd || from.charCodeAt(i) === 47) {
                        if (out.length === 0) out += "..";
                        else out += "/..";
                    }
                }
                if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
                else {
                    toStart += lastCommonSep;
                    if (to.charCodeAt(toStart) === 47) ++toStart;
                    return to.slice(toStart);
                }
            },
            _makeLong: function _makeLong(path5) {
                return path5;
            },
            dirname: function dirname(path5) {
                assertPath(path5);
                if (path5.length === 0) return ".";
                var code = path5.charCodeAt(0);
                var hasRoot = code === 47;
                var end = -1;
                var matchedSlash = true;
                for(var i = path5.length - 1; i >= 1; --i){
                    code = path5.charCodeAt(i);
                    if (code === 47) {
                        if (!matchedSlash) {
                            end = i;
                            break;
                        }
                    } else {
                        matchedSlash = false;
                    }
                }
                if (end === -1) return hasRoot ? "/" : ".";
                if (hasRoot && end === 1) return "//";
                return path5.slice(0, end);
            },
            basename: function basename4(path5, ext) {
                if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
                assertPath(path5);
                var start = 0;
                var end = -1;
                var matchedSlash = true;
                var i;
                if (ext !== void 0 && ext.length > 0 && ext.length <= path5.length) {
                    if (ext.length === path5.length && ext === path5) return "";
                    var extIdx = ext.length - 1;
                    var firstNonSlashEnd = -1;
                    for(i = path5.length - 1; i >= 0; --i){
                        var code = path5.charCodeAt(i);
                        if (code === 47) {
                            if (!matchedSlash) {
                                start = i + 1;
                                break;
                            }
                        } else {
                            if (firstNonSlashEnd === -1) {
                                matchedSlash = false;
                                firstNonSlashEnd = i + 1;
                            }
                            if (extIdx >= 0) {
                                if (code === ext.charCodeAt(extIdx)) {
                                    if (--extIdx === -1) {
                                        end = i;
                                    }
                                } else {
                                    extIdx = -1;
                                    end = firstNonSlashEnd;
                                }
                            }
                        }
                    }
                    if (start === end) end = firstNonSlashEnd;
                    else if (end === -1) end = path5.length;
                    return path5.slice(start, end);
                } else {
                    for(i = path5.length - 1; i >= 0; --i){
                        if (path5.charCodeAt(i) === 47) {
                            if (!matchedSlash) {
                                start = i + 1;
                                break;
                            }
                        } else if (end === -1) {
                            matchedSlash = false;
                            end = i + 1;
                        }
                    }
                    if (end === -1) return "";
                    return path5.slice(start, end);
                }
            },
            extname: function extname2(path5) {
                assertPath(path5);
                var startDot = -1;
                var startPart = 0;
                var end = -1;
                var matchedSlash = true;
                var preDotState = 0;
                for(var i = path5.length - 1; i >= 0; --i){
                    var code = path5.charCodeAt(i);
                    if (code === 47) {
                        if (!matchedSlash) {
                            startPart = i + 1;
                            break;
                        }
                        continue;
                    }
                    if (end === -1) {
                        matchedSlash = false;
                        end = i + 1;
                    }
                    if (code === 46) {
                        if (startDot === -1) startDot = i;
                        else if (preDotState !== 1) preDotState = 1;
                    } else if (startDot !== -1) {
                        preDotState = -1;
                    }
                }
                if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
                preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
                preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
                    return "";
                }
                return path5.slice(startDot, end);
            },
            format: function format5(pathObject) {
                if (pathObject === null || typeof pathObject !== "object") {
                    throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
                }
                return _format("/", pathObject);
            },
            parse: function parse7(path5) {
                assertPath(path5);
                var ret = {
                    root: "",
                    dir: "",
                    base: "",
                    ext: "",
                    name: ""
                };
                if (path5.length === 0) return ret;
                var code = path5.charCodeAt(0);
                var isAbsolute2 = code === 47;
                var start;
                if (isAbsolute2) {
                    ret.root = "/";
                    start = 1;
                } else {
                    start = 0;
                }
                var startDot = -1;
                var startPart = 0;
                var end = -1;
                var matchedSlash = true;
                var i = path5.length - 1;
                var preDotState = 0;
                for(; i >= start; --i){
                    code = path5.charCodeAt(i);
                    if (code === 47) {
                        if (!matchedSlash) {
                            startPart = i + 1;
                            break;
                        }
                        continue;
                    }
                    if (end === -1) {
                        matchedSlash = false;
                        end = i + 1;
                    }
                    if (code === 46) {
                        if (startDot === -1) startDot = i;
                        else if (preDotState !== 1) preDotState = 1;
                    } else if (startDot !== -1) {
                        preDotState = -1;
                    }
                }
                if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
                preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
                preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
                    if (end !== -1) {
                        if (startPart === 0 && isAbsolute2) ret.base = ret.name = path5.slice(1, end);
                        else ret.base = ret.name = path5.slice(startPart, end);
                    }
                } else {
                    if (startPart === 0 && isAbsolute2) {
                        ret.name = path5.slice(1, startDot);
                        ret.base = path5.slice(1, end);
                    } else {
                        ret.name = path5.slice(startPart, startDot);
                        ret.base = path5.slice(startPart, end);
                    }
                    ret.ext = path5.slice(startDot, end);
                }
                if (startPart > 0) ret.dir = path5.slice(0, startPart - 1);
                else if (isAbsolute2) ret.dir = "/";
                return ret;
            },
            sep: "/",
            delimiter: ":",
            win32: null,
            posix: null
        };
        posix.posix = posix;
        module.exports = posix;
    }
});
// ../../node_modules/yaml-language-server/node_modules/ajv/dist/refs/json-schema-draft-07.json
var require_json_schema_draft_07 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/ajv/dist/refs/json-schema-draft-07.json" (exports, module) {
        module.exports = {
            $schema: "http://json-schema.org/draft-07/schema#",
            $id: "http://json-schema.org/draft-07/schema#",
            title: "Core schema meta-schema",
            definitions: {
                schemaArray: {
                    type: "array",
                    minItems: 1,
                    items: {
                        $ref: "#"
                    }
                },
                nonNegativeInteger: {
                    type: "integer",
                    minimum: 0
                },
                nonNegativeIntegerDefault0: {
                    allOf: [
                        {
                            $ref: "#/definitions/nonNegativeInteger"
                        },
                        {
                            default: 0
                        }
                    ]
                },
                simpleTypes: {
                    enum: [
                        "array",
                        "boolean",
                        "integer",
                        "null",
                        "number",
                        "object",
                        "string"
                    ]
                },
                stringArray: {
                    type: "array",
                    items: {
                        type: "string"
                    },
                    uniqueItems: true,
                    default: []
                }
            },
            type: [
                "object",
                "boolean"
            ],
            properties: {
                $id: {
                    type: "string",
                    format: "uri-reference"
                },
                $schema: {
                    type: "string",
                    format: "uri"
                },
                $ref: {
                    type: "string",
                    format: "uri-reference"
                },
                $comment: {
                    type: "string"
                },
                title: {
                    type: "string"
                },
                description: {
                    type: "string"
                },
                default: true,
                readOnly: {
                    type: "boolean",
                    default: false
                },
                examples: {
                    type: "array",
                    items: true
                },
                multipleOf: {
                    type: "number",
                    exclusiveMinimum: 0
                },
                maximum: {
                    type: "number"
                },
                exclusiveMaximum: {
                    type: "number"
                },
                minimum: {
                    type: "number"
                },
                exclusiveMinimum: {
                    type: "number"
                },
                maxLength: {
                    $ref: "#/definitions/nonNegativeInteger"
                },
                minLength: {
                    $ref: "#/definitions/nonNegativeIntegerDefault0"
                },
                pattern: {
                    type: "string",
                    format: "regex"
                },
                additionalItems: {
                    $ref: "#"
                },
                items: {
                    anyOf: [
                        {
                            $ref: "#"
                        },
                        {
                            $ref: "#/definitions/schemaArray"
                        }
                    ],
                    default: true
                },
                maxItems: {
                    $ref: "#/definitions/nonNegativeInteger"
                },
                minItems: {
                    $ref: "#/definitions/nonNegativeIntegerDefault0"
                },
                uniqueItems: {
                    type: "boolean",
                    default: false
                },
                contains: {
                    $ref: "#"
                },
                maxProperties: {
                    $ref: "#/definitions/nonNegativeInteger"
                },
                minProperties: {
                    $ref: "#/definitions/nonNegativeIntegerDefault0"
                },
                required: {
                    $ref: "#/definitions/stringArray"
                },
                additionalProperties: {
                    $ref: "#"
                },
                definitions: {
                    type: "object",
                    additionalProperties: {
                        $ref: "#"
                    },
                    default: {}
                },
                properties: {
                    type: "object",
                    additionalProperties: {
                        $ref: "#"
                    },
                    default: {}
                },
                patternProperties: {
                    type: "object",
                    additionalProperties: {
                        $ref: "#"
                    },
                    propertyNames: {
                        format: "regex"
                    },
                    default: {}
                },
                dependencies: {
                    type: "object",
                    additionalProperties: {
                        anyOf: [
                            {
                                $ref: "#"
                            },
                            {
                                $ref: "#/definitions/stringArray"
                            }
                        ]
                    }
                },
                propertyNames: {
                    $ref: "#"
                },
                const: true,
                enum: {
                    type: "array",
                    items: true,
                    minItems: 1,
                    uniqueItems: true
                },
                type: {
                    anyOf: [
                        {
                            $ref: "#/definitions/simpleTypes"
                        },
                        {
                            type: "array",
                            items: {
                                $ref: "#/definitions/simpleTypes"
                            },
                            minItems: 1,
                            uniqueItems: true
                        }
                    ]
                },
                format: {
                    type: "string"
                },
                contentMediaType: {
                    type: "string"
                },
                contentEncoding: {
                    type: "string"
                },
                if: {
                    $ref: "#"
                },
                then: {
                    $ref: "#"
                },
                else: {
                    $ref: "#"
                },
                allOf: {
                    $ref: "#/definitions/schemaArray"
                },
                anyOf: {
                    $ref: "#/definitions/schemaArray"
                },
                oneOf: {
                    $ref: "#/definitions/schemaArray"
                },
                not: {
                    $ref: "#"
                }
            },
            default: true
        };
    }
});
// ../../node_modules/prettier/standalone.js
var require_standalone = __commonJS({
    "../../node_modules/prettier/standalone.js" (exports, module) {
        (function(e) {
            if (typeof exports == "object" && typeof module == "object") module.exports = e();
            else if (typeof define == "function" && __webpack_require__.amdO) define(e);
            else {
                var f2 = typeof globalThis < "u" ? globalThis : typeof __webpack_require__.g < "u" ? __webpack_require__.g : typeof self < "u" ? self : this || {};
                f2.prettier = e();
            }
        })(function() {
            "use strict";
            var xe = (e, r)=>()=>(r || e((r = {
                        exports: {}
                    }).exports, r), r.exports);
            var pt = xe((r0, pu)=>{
                var ir = function(e) {
                    return e && e.Math == Math && e;
                };
                pu.exports = ir(typeof globalThis == "object" && globalThis) || ir(typeof window == "object" && window) || ir(typeof self == "object" && self) || ir(typeof __webpack_require__.g == "object" && __webpack_require__.g) || /* @__PURE__ */ function() {
                    return this;
                }() || Function("return this")();
            });
            var Dt = xe((n0, fu)=>{
                fu.exports = function(e) {
                    try {
                        return !!e();
                    } catch  {
                        return true;
                    }
                };
            });
            var yt = xe((u0, Du)=>{
                var Mo = Dt();
                Du.exports = !Mo(function() {
                    return Object.defineProperty({}, 1, {
                        get: function() {
                            return 7;
                        }
                    })[1] != 7;
                });
            });
            var ar = xe((s0, mu)=>{
                var Ro = Dt();
                mu.exports = !Ro(function() {
                    var e = (function() {}).bind();
                    return typeof e != "function" || e.hasOwnProperty("prototype");
                });
            });
            var At = xe((i0, du)=>{
                var $o = ar(), or = Function.prototype.call;
                du.exports = $o ? or.bind(or) : function() {
                    return or.apply(or, arguments);
                };
            });
            var vu = xe((hu)=>{
                "use strict";
                var gu = {}.propertyIsEnumerable, yu = Object.getOwnPropertyDescriptor, Vo = yu && !gu.call({
                    1: 2
                }, 1);
                hu.f = Vo ? function(r) {
                    var t1 = yu(this, r);
                    return !!t1 && t1.enumerable;
                } : gu;
            });
            var lr = xe((o0, Cu)=>{
                Cu.exports = function(e, r) {
                    return {
                        enumerable: !(e & 1),
                        configurable: !(e & 2),
                        writable: !(e & 4),
                        value: r
                    };
                };
            });
            var mt = xe((l0, Au)=>{
                var Eu = ar(), Fu = Function.prototype, Wr = Fu.call, Wo = Eu && Fu.bind.bind(Wr, Wr);
                Au.exports = Eu ? Wo : function(e) {
                    return function() {
                        return Wr.apply(e, arguments);
                    };
                };
            });
            var Vt = xe((c0, xu)=>{
                var Su = mt(), Ho = Su({}.toString), Go = Su("".slice);
                xu.exports = function(e) {
                    return Go(Ho(e), 8, -1);
                };
            });
            var Tu = xe((p0, bu)=>{
                var Uo = mt(), Jo = Dt(), zo = Vt(), Hr = Object, Xo = Uo("".split);
                bu.exports = Jo(function() {
                    return !Hr("z").propertyIsEnumerable(0);
                }) ? function(e) {
                    return zo(e) == "String" ? Xo(e, "") : Hr(e);
                } : Hr;
            });
            var cr = xe((f0, Bu)=>{
                Bu.exports = function(e) {
                    return e == null;
                };
            });
            var Gr = xe((D0, Nu)=>{
                var Ko = cr(), Yo = TypeError;
                Nu.exports = function(e) {
                    if (Ko(e)) throw Yo("Can't call method on " + e);
                    return e;
                };
            });
            var pr = xe((m0, wu)=>{
                var Qo = Tu(), Zo = Gr();
                wu.exports = function(e) {
                    return Qo(Zo(e));
                };
            });
            var Jr = xe((d0, _u)=>{
                var Ur = typeof document == "object" && document.all, el = typeof Ur > "u" && Ur !== void 0;
                _u.exports = {
                    all: Ur,
                    IS_HTMLDDA: el
                };
            });
            var ot = xe((g0, Iu)=>{
                var Pu = Jr(), tl = Pu.all;
                Iu.exports = Pu.IS_HTMLDDA ? function(e) {
                    return typeof e == "function" || e === tl;
                } : function(e) {
                    return typeof e == "function";
                };
            });
            var St = xe((y0, Ou)=>{
                var ku = ot(), Lu = Jr(), rl = Lu.all;
                Ou.exports = Lu.IS_HTMLDDA ? function(e) {
                    return typeof e == "object" ? e !== null : ku(e) || e === rl;
                } : function(e) {
                    return typeof e == "object" ? e !== null : ku(e);
                };
            });
            var Wt = xe((h0, ju)=>{
                var zr = pt(), nl = ot(), ul = function(e) {
                    return nl(e) ? e : void 0;
                };
                ju.exports = function(e, r) {
                    return arguments.length < 2 ? ul(zr[e]) : zr[e] && zr[e][r];
                };
            });
            var Xr = xe((v0, qu)=>{
                var sl = mt();
                qu.exports = sl({}.isPrototypeOf);
            });
            var Ru = xe((C0, Mu)=>{
                var il = Wt();
                Mu.exports = il("navigator", "userAgent") || "";
            });
            var Ju = xe((E0, Uu)=>{
                var Gu = pt(), Kr = Ru(), $u = Gu.process, Vu = Gu.Deno, Wu = $u && $u.versions || Vu && Vu.version, Hu = Wu && Wu.v8, dt, fr;
                Hu && (dt = Hu.split("."), fr = dt[0] > 0 && dt[0] < 4 ? 1 : +(dt[0] + dt[1]));
                !fr && Kr && (dt = Kr.match(/Edge\/(\d+)/), (!dt || dt[1] >= 74) && (dt = Kr.match(/Chrome\/(\d+)/), dt && (fr = +dt[1])));
                Uu.exports = fr;
            });
            var Yr = xe((F0, Xu)=>{
                var zu = Ju(), al = Dt();
                Xu.exports = !!Object.getOwnPropertySymbols && !al(function() {
                    var e = Symbol();
                    return !String(e) || !(Object(e) instanceof Symbol) || !Symbol.sham && zu && zu < 41;
                });
            });
            var Qr = xe((A0, Ku)=>{
                var ol = Yr();
                Ku.exports = ol && !Symbol.sham && typeof Symbol.iterator == "symbol";
            });
            var Zr = xe((S0, Yu)=>{
                var ll = Wt(), cl = ot(), pl = Xr(), fl = Qr(), Dl = Object;
                Yu.exports = fl ? function(e) {
                    return typeof e == "symbol";
                } : function(e) {
                    var r = ll("Symbol");
                    return cl(r) && pl(r.prototype, Dl(e));
                };
            });
            var Dr = xe((x0, Qu)=>{
                var ml = String;
                Qu.exports = function(e) {
                    try {
                        return ml(e);
                    } catch  {
                        return "Object";
                    }
                };
            });
            var Ht = xe((b0, Zu)=>{
                var dl = ot(), gl = Dr(), yl = TypeError;
                Zu.exports = function(e) {
                    if (dl(e)) return e;
                    throw yl(gl(e) + " is not a function");
                };
            });
            var mr = xe((T0, es)=>{
                var hl = Ht(), vl = cr();
                es.exports = function(e, r) {
                    var t1 = e[r];
                    return vl(t1) ? void 0 : hl(t1);
                };
            });
            var rs = xe((B0, ts)=>{
                var en = At(), tn = ot(), rn = St(), Cl = TypeError;
                ts.exports = function(e, r) {
                    var t1, s;
                    if (r === "string" && tn(t1 = e.toString) && !rn(s = en(t1, e)) || tn(t1 = e.valueOf) && !rn(s = en(t1, e)) || r !== "string" && tn(t1 = e.toString) && !rn(s = en(t1, e))) return s;
                    throw Cl("Can't convert object to primitive value");
                };
            });
            var us = xe((N0, ns)=>{
                ns.exports = false;
            });
            var dr = xe((w0, is)=>{
                var ss = pt(), El = Object.defineProperty;
                is.exports = function(e, r) {
                    try {
                        El(ss, e, {
                            value: r,
                            configurable: true,
                            writable: true
                        });
                    } catch  {
                        ss[e] = r;
                    }
                    return r;
                };
            });
            var gr = xe((_0, os)=>{
                var Fl = pt(), Al = dr(), as = "__core-js_shared__", Sl = Fl[as] || Al(as, {});
                os.exports = Sl;
            });
            var nn = xe((P0, cs)=>{
                var xl = us(), ls = gr();
                (cs.exports = function(e, r) {
                    return ls[e] || (ls[e] = r !== void 0 ? r : {});
                })("versions", []).push({
                    version: "3.26.1",
                    mode: xl ? "pure" : "global",
                    copyright: "\xA9 2014-2022 Denis Pushkarev (zloirock.ru)",
                    license: "https://github.com/zloirock/core-js/blob/v3.26.1/LICENSE",
                    source: "https://github.com/zloirock/core-js"
                });
            });
            var yr = xe((I0, ps)=>{
                var bl = Gr(), Tl = Object;
                ps.exports = function(e) {
                    return Tl(bl(e));
                };
            });
            var Ct = xe((k0, fs)=>{
                var Bl = mt(), Nl = yr(), wl = Bl({}.hasOwnProperty);
                fs.exports = Object.hasOwn || function(r, t1) {
                    return wl(Nl(r), t1);
                };
            });
            var un = xe((L0, Ds)=>{
                var _l = mt(), Pl = 0, Il = Math.random(), kl = _l(1..toString);
                Ds.exports = function(e) {
                    return "Symbol(" + (e === void 0 ? "" : e) + ")_" + kl(++Pl + Il, 36);
                };
            });
            var bt = xe((O0, hs)=>{
                var Ll = pt(), Ol = nn(), ms = Ct(), jl = un(), ds = Yr(), ys = Qr(), It = Ol("wks"), xt = Ll.Symbol, gs = xt && xt.for, ql = ys ? xt : xt && xt.withoutSetter || jl;
                hs.exports = function(e) {
                    if (!ms(It, e) || !(ds || typeof It[e] == "string")) {
                        var r = "Symbol." + e;
                        ds && ms(xt, e) ? It[e] = xt[e] : ys && gs ? It[e] = gs(r) : It[e] = ql(r);
                    }
                    return It[e];
                };
            });
            var Fs = xe((j0, Es)=>{
                var Ml = At(), vs = St(), Cs = Zr(), Rl = mr(), $l = rs(), Vl = bt(), Wl = TypeError, Hl = Vl("toPrimitive");
                Es.exports = function(e, r) {
                    if (!vs(e) || Cs(e)) return e;
                    var t1 = Rl(e, Hl), s;
                    if (t1) {
                        if (r === void 0 && (r = "default"), s = Ml(t1, e, r), !vs(s) || Cs(s)) return s;
                        throw Wl("Can't convert object to primitive value");
                    }
                    return r === void 0 && (r = "number"), $l(e, r);
                };
            });
            var hr = xe((q0, As)=>{
                var Gl = Fs(), Ul = Zr();
                As.exports = function(e) {
                    var r = Gl(e, "string");
                    return Ul(r) ? r : r + "";
                };
            });
            var bs = xe((M0, xs)=>{
                var Jl = pt(), Ss = St(), sn = Jl.document, zl = Ss(sn) && Ss(sn.createElement);
                xs.exports = function(e) {
                    return zl ? sn.createElement(e) : {};
                };
            });
            var an = xe((R0, Ts)=>{
                var Xl = yt(), Kl = Dt(), Yl = bs();
                Ts.exports = !Xl && !Kl(function() {
                    return Object.defineProperty(Yl("div"), "a", {
                        get: function() {
                            return 7;
                        }
                    }).a != 7;
                });
            });
            var on = xe((Ns)=>{
                var Ql = yt(), Zl = At(), ec = vu(), tc = lr(), rc = pr(), nc = hr(), uc = Ct(), sc = an(), Bs = Object.getOwnPropertyDescriptor;
                Ns.f = Ql ? Bs : function(r, t1) {
                    if (r = rc(r), t1 = nc(t1), sc) try {
                        return Bs(r, t1);
                    } catch  {}
                    if (uc(r, t1)) return tc(!Zl(ec.f, r, t1), r[t1]);
                };
            });
            var _s = xe((V0, ws)=>{
                var ic = yt(), ac = Dt();
                ws.exports = ic && ac(function() {
                    return Object.defineProperty(function() {}, "prototype", {
                        value: 42,
                        writable: false
                    }).prototype != 42;
                });
            });
            var Tt = xe((W0, Ps)=>{
                var oc = St(), lc = String, cc = TypeError;
                Ps.exports = function(e) {
                    if (oc(e)) return e;
                    throw cc(lc(e) + " is not an object");
                };
            });
            var kt = xe((ks)=>{
                var pc = yt(), fc = an(), Dc = _s(), vr = Tt(), Is = hr(), mc = TypeError, ln = Object.defineProperty, dc = Object.getOwnPropertyDescriptor, cn = "enumerable", pn = "configurable", fn = "writable";
                ks.f = pc ? Dc ? function(r, t1, s) {
                    if (vr(r), t1 = Is(t1), vr(s), typeof r == "function" && t1 === "prototype" && "value" in s && fn in s && !s[fn]) {
                        var a2 = dc(r, t1);
                        a2 && a2[fn] && (r[t1] = s.value, s = {
                            configurable: pn in s ? s[pn] : a2[pn],
                            enumerable: cn in s ? s[cn] : a2[cn],
                            writable: false
                        });
                    }
                    return ln(r, t1, s);
                } : ln : function(r, t1, s) {
                    if (vr(r), t1 = Is(t1), vr(s), fc) try {
                        return ln(r, t1, s);
                    } catch  {}
                    if ("get" in s || "set" in s) throw mc("Accessors not supported");
                    return "value" in s && (r[t1] = s.value), r;
                };
            });
            var Dn = xe((G0, Ls)=>{
                var gc = yt(), yc = kt(), hc = lr();
                Ls.exports = gc ? function(e, r, t1) {
                    return yc.f(e, r, hc(1, t1));
                } : function(e, r, t1) {
                    return e[r] = t1, e;
                };
            });
            var qs = xe((U0, js)=>{
                var mn = yt(), vc = Ct(), Os = Function.prototype, Cc = mn && Object.getOwnPropertyDescriptor, dn = vc(Os, "name"), Ec = dn && (function() {}).name === "something", Fc = dn && (!mn || mn && Cc(Os, "name").configurable);
                js.exports = {
                    EXISTS: dn,
                    PROPER: Ec,
                    CONFIGURABLE: Fc
                };
            });
            var yn = xe((J0, Ms)=>{
                var Ac = mt(), Sc = ot(), gn = gr(), xc = Ac(Function.toString);
                Sc(gn.inspectSource) || (gn.inspectSource = function(e) {
                    return xc(e);
                });
                Ms.exports = gn.inspectSource;
            });
            var Vs = xe((z0, $s)=>{
                var bc = pt(), Tc = ot(), Rs = bc.WeakMap;
                $s.exports = Tc(Rs) && /native code/.test(String(Rs));
            });
            var Gs = xe((X0, Hs)=>{
                var Bc = nn(), Nc = un(), Ws = Bc("keys");
                Hs.exports = function(e) {
                    return Ws[e] || (Ws[e] = Nc(e));
                };
            });
            var hn = xe((K0, Us)=>{
                Us.exports = {};
            });
            var Ks = xe((Y0, Xs)=>{
                var wc = Vs(), zs = pt(), _c = St(), Pc = Dn(), vn = Ct(), Cn = gr(), Ic = Gs(), kc = hn(), Js = "Object already initialized", En = zs.TypeError, Lc = zs.WeakMap, Cr, Gt, Er, Oc = function(e) {
                    return Er(e) ? Gt(e) : Cr(e, {});
                }, jc = function(e) {
                    return function(r) {
                        var t1;
                        if (!_c(r) || (t1 = Gt(r)).type !== e) throw En("Incompatible receiver, " + e + " required");
                        return t1;
                    };
                };
                wc || Cn.state ? (gt = Cn.state || (Cn.state = new Lc()), gt.get = gt.get, gt.has = gt.has, gt.set = gt.set, Cr = function(e, r) {
                    if (gt.has(e)) throw En(Js);
                    return r.facade = e, gt.set(e, r), r;
                }, Gt = function(e) {
                    return gt.get(e) || {};
                }, Er = function(e) {
                    return gt.has(e);
                }) : (Bt = Ic("state"), kc[Bt] = true, Cr = function(e, r) {
                    if (vn(e, Bt)) throw En(Js);
                    return r.facade = e, Pc(e, Bt, r), r;
                }, Gt = function(e) {
                    return vn(e, Bt) ? e[Bt] : {};
                }, Er = function(e) {
                    return vn(e, Bt);
                });
                var gt, Bt;
                Xs.exports = {
                    set: Cr,
                    get: Gt,
                    has: Er,
                    enforce: Oc,
                    getterFor: jc
                };
            });
            var An = xe((Q0, Qs)=>{
                var qc = Dt(), Mc = ot(), Fr = Ct(), Fn = yt(), Rc = qs().CONFIGURABLE, $c = yn(), Ys = Ks(), Vc = Ys.enforce, Wc = Ys.get, Ar = Object.defineProperty, Hc = Fn && !qc(function() {
                    return Ar(function() {}, "length", {
                        value: 8
                    }).length !== 8;
                }), Gc = String(String).split("String"), Uc = Qs.exports = function(e, r, t1) {
                    String(r).slice(0, 7) === "Symbol(" && (r = "[" + String(r).replace(/^Symbol\(([^)]*)\)/, "$1") + "]"), t1 && t1.getter && (r = "get " + r), t1 && t1.setter && (r = "set " + r), (!Fr(e, "name") || Rc && e.name !== r) && (Fn ? Ar(e, "name", {
                        value: r,
                        configurable: true
                    }) : e.name = r), Hc && t1 && Fr(t1, "arity") && e.length !== t1.arity && Ar(e, "length", {
                        value: t1.arity
                    });
                    try {
                        t1 && Fr(t1, "constructor") && t1.constructor ? Fn && Ar(e, "prototype", {
                            writable: false
                        }) : e.prototype && (e.prototype = void 0);
                    } catch  {}
                    var s = Vc(e);
                    return Fr(s, "source") || (s.source = Gc.join(typeof r == "string" ? r : "")), e;
                };
                Function.prototype.toString = Uc(function() {
                    return Mc(this) && Wc(this).source || $c(this);
                }, "toString");
            });
            var ei = xe((Z0, Zs)=>{
                var Jc = ot(), zc = kt(), Xc = An(), Kc = dr();
                Zs.exports = function(e, r, t1, s) {
                    s || (s = {});
                    var a2 = s.enumerable, n = s.name !== void 0 ? s.name : r;
                    if (Jc(t1) && Xc(t1, n, s), s.global) a2 ? e[r] = t1 : Kc(r, t1);
                    else {
                        try {
                            s.unsafe ? e[r] && (a2 = true) : delete e[r];
                        } catch  {}
                        a2 ? e[r] = t1 : zc.f(e, r, {
                            value: t1,
                            enumerable: false,
                            configurable: !s.nonConfigurable,
                            writable: !s.nonWritable
                        });
                    }
                    return e;
                };
            });
            var ri = xe((ey, ti)=>{
                var Yc = Math.ceil, Qc = Math.floor;
                ti.exports = Math.trunc || function(r) {
                    var t1 = +r;
                    return (t1 > 0 ? Qc : Yc)(t1);
                };
            });
            var Sr = xe((ty, ni)=>{
                var Zc = ri();
                ni.exports = function(e) {
                    var r = +e;
                    return r !== r || r === 0 ? 0 : Zc(r);
                };
            });
            var si = xe((ry, ui)=>{
                var ep = Sr(), tp = Math.max, rp = Math.min;
                ui.exports = function(e, r) {
                    var t1 = ep(e);
                    return t1 < 0 ? tp(t1 + r, 0) : rp(t1, r);
                };
            });
            var ai = xe((ny, ii)=>{
                var np = Sr(), up = Math.min;
                ii.exports = function(e) {
                    return e > 0 ? up(np(e), 9007199254740991) : 0;
                };
            });
            var Lt = xe((uy, oi)=>{
                var sp = ai();
                oi.exports = function(e) {
                    return sp(e.length);
                };
            });
            var pi = xe((sy, ci)=>{
                var ip = pr(), ap = si(), op = Lt(), li = function(e) {
                    return function(r, t1, s) {
                        var a2 = ip(r), n = op(a2), u = ap(s, n), i;
                        if (e && t1 != t1) {
                            for(; n > u;)if (i = a2[u++], i != i) return true;
                        } else for(; n > u; u++)if ((e || u in a2) && a2[u] === t1) return e || u || 0;
                        return !e && -1;
                    };
                };
                ci.exports = {
                    includes: li(true),
                    indexOf: li(false)
                };
            });
            var mi = xe((iy, Di)=>{
                var lp = mt(), Sn = Ct(), cp = pr(), pp = pi().indexOf, fp = hn(), fi = lp([].push);
                Di.exports = function(e, r) {
                    var t1 = cp(e), s = 0, a2 = [], n;
                    for(n in t1)!Sn(fp, n) && Sn(t1, n) && fi(a2, n);
                    for(; r.length > s;)Sn(t1, n = r[s++]) && (~pp(a2, n) || fi(a2, n));
                    return a2;
                };
            });
            var gi = xe((ay, di)=>{
                di.exports = [
                    "constructor",
                    "hasOwnProperty",
                    "isPrototypeOf",
                    "propertyIsEnumerable",
                    "toLocaleString",
                    "toString",
                    "valueOf"
                ];
            });
            var hi = xe((yi)=>{
                var Dp = mi(), mp = gi(), dp = mp.concat("length", "prototype");
                yi.f = Object.getOwnPropertyNames || function(r) {
                    return Dp(r, dp);
                };
            });
            var Ci = xe((vi)=>{
                vi.f = Object.getOwnPropertySymbols;
            });
            var Fi = xe((cy, Ei)=>{
                var gp = Wt(), yp = mt(), hp = hi(), vp = Ci(), Cp = Tt(), Ep = yp([].concat);
                Ei.exports = gp("Reflect", "ownKeys") || function(r) {
                    var t1 = hp.f(Cp(r)), s = vp.f;
                    return s ? Ep(t1, s(r)) : t1;
                };
            });
            var xi = xe((py, Si)=>{
                var Ai = Ct(), Fp = Fi(), Ap = on(), Sp = kt();
                Si.exports = function(e, r, t1) {
                    for(var s = Fp(r), a2 = Sp.f, n = Ap.f, u = 0; u < s.length; u++){
                        var i = s[u];
                        !Ai(e, i) && !(t1 && Ai(t1, i)) && a2(e, i, n(r, i));
                    }
                };
            });
            var Ti = xe((fy, bi)=>{
                var xp = Dt(), bp = ot(), Tp = /#|\.prototype\./, Ut = function(e, r) {
                    var t1 = Np[Bp(e)];
                    return t1 == _p ? true : t1 == wp ? false : bp(r) ? xp(r) : !!r;
                }, Bp = Ut.normalize = function(e) {
                    return String(e).replace(Tp, ".").toLowerCase();
                }, Np = Ut.data = {}, wp = Ut.NATIVE = "N", _p = Ut.POLYFILL = "P";
                bi.exports = Ut;
            });
            var Jt = xe((Dy, Bi)=>{
                var xn = pt(), Pp = on().f, Ip = Dn(), kp = ei(), Lp = dr(), Op = xi(), jp = Ti();
                Bi.exports = function(e, r) {
                    var t1 = e.target, s = e.global, a2 = e.stat, n, u, i, l, p, y;
                    if (s ? u = xn : a2 ? u = xn[t1] || Lp(t1, {}) : u = (xn[t1] || {}).prototype, u) for(i in r){
                        if (p = r[i], e.dontCallGetSet ? (y = Pp(u, i), l = y && y.value) : l = u[i], n = jp(s ? i : t1 + (a2 ? "." : "#") + i, e.forced), !n && l !== void 0) {
                            if (typeof p == typeof l) continue;
                            Op(p, l);
                        }
                        (e.sham || l && l.sham) && Ip(p, "sham", true), kp(u, i, p, e);
                    }
                };
            });
            var bn = xe((my, Ni)=>{
                var qp = Vt();
                Ni.exports = Array.isArray || function(r) {
                    return qp(r) == "Array";
                };
            });
            var _i = xe((dy, wi)=>{
                var Mp = TypeError, Rp = 9007199254740991;
                wi.exports = function(e) {
                    if (e > Rp) throw Mp("Maximum allowed index exceeded");
                    return e;
                };
            });
            var Ii = xe((gy, Pi)=>{
                var $p = Vt(), Vp = mt();
                Pi.exports = function(e) {
                    if ($p(e) === "Function") return Vp(e);
                };
            });
            var Tn = xe((yy, Li)=>{
                var ki = Ii(), Wp = Ht(), Hp = ar(), Gp = ki(ki.bind);
                Li.exports = function(e, r) {
                    return Wp(e), r === void 0 ? e : Hp ? Gp(e, r) : function() {
                        return e.apply(r, arguments);
                    };
                };
            });
            var Bn = xe((hy, ji)=>{
                "use strict";
                var Up = bn(), Jp = Lt(), zp = _i(), Xp = Tn(), Oi = function(e, r, t1, s, a2, n, u, i) {
                    for(var l = a2, p = 0, y = u ? Xp(u, i) : false, h, g; p < s;)p in t1 && (h = y ? y(t1[p], p, r) : t1[p], n > 0 && Up(h) ? (g = Jp(h), l = Oi(e, r, h, g, l, n - 1) - 1) : (zp(l + 1), e[l] = h), l++), p++;
                    return l;
                };
                ji.exports = Oi;
            });
            var Ri = xe((vy, Mi)=>{
                var Kp = bt(), Yp = Kp("toStringTag"), qi = {};
                qi[Yp] = "z";
                Mi.exports = String(qi) === "[object z]";
            });
            var Nn = xe((Cy, $i)=>{
                var Qp = Ri(), Zp = ot(), xr = Vt(), ef = bt(), tf = ef("toStringTag"), rf = Object, nf = xr(/* @__PURE__ */ function() {
                    return arguments;
                }()) == "Arguments", uf = function(e, r) {
                    try {
                        return e[r];
                    } catch  {}
                };
                $i.exports = Qp ? xr : function(e) {
                    var r, t1, s;
                    return e === void 0 ? "Undefined" : e === null ? "Null" : typeof (t1 = uf(r = rf(e), tf)) == "string" ? t1 : nf ? xr(r) : (s = xr(r)) == "Object" && Zp(r.callee) ? "Arguments" : s;
                };
            });
            var Ji = xe((Ey, Ui)=>{
                var sf = mt(), af = Dt(), Vi = ot(), of = Nn(), lf = Wt(), cf = yn(), Wi = function() {}, pf = [], Hi = lf("Reflect", "construct"), wn = /^\s*(?:class|function)\b/, ff = sf(wn.exec), Df = !wn.exec(Wi), zt = function(r) {
                    if (!Vi(r)) return false;
                    try {
                        return Hi(Wi, pf, r), true;
                    } catch  {
                        return false;
                    }
                }, Gi = function(r) {
                    if (!Vi(r)) return false;
                    switch(of(r)){
                        case "AsyncFunction":
                        case "GeneratorFunction":
                        case "AsyncGeneratorFunction":
                            return false;
                    }
                    try {
                        return Df || !!ff(wn, cf(r));
                    } catch  {
                        return true;
                    }
                };
                Gi.sham = true;
                Ui.exports = !Hi || af(function() {
                    var e;
                    return zt(zt.call) || !zt(Object) || !zt(function() {
                        e = true;
                    }) || e;
                }) ? Gi : zt;
            });
            var Yi = xe((Fy, Ki)=>{
                var zi = bn(), mf = Ji(), df = St(), gf = bt(), yf = gf("species"), Xi = Array;
                Ki.exports = function(e) {
                    var r;
                    return zi(e) && (r = e.constructor, mf(r) && (r === Xi || zi(r.prototype)) ? r = void 0 : df(r) && (r = r[yf], r === null && (r = void 0))), r === void 0 ? Xi : r;
                };
            });
            var _n = xe((Ay, Qi)=>{
                var hf = Yi();
                Qi.exports = function(e, r) {
                    return new (hf(e))(r === 0 ? 0 : r);
                };
            });
            var Zi = xe(()=>{
                "use strict";
                var vf = Jt(), Cf = Bn(), Ef = Ht(), Ff = yr(), Af = Lt(), Sf = _n();
                vf({
                    target: "Array",
                    proto: true
                }, {
                    flatMap: function(r) {
                        var t1 = Ff(this), s = Af(t1), a2;
                        return Ef(r), a2 = Sf(t1, 0), a2.length = Cf(a2, t1, t1, s, 0, 1, r, arguments.length > 1 ? arguments[1] : void 0), a2;
                    }
                });
            });
            var Pn = xe((by, ea)=>{
                ea.exports = {};
            });
            var ra = xe((Ty, ta)=>{
                var xf = bt(), bf = Pn(), Tf = xf("iterator"), Bf = Array.prototype;
                ta.exports = function(e) {
                    return e !== void 0 && (bf.Array === e || Bf[Tf] === e);
                };
            });
            var In = xe((By, ua)=>{
                var Nf = Nn(), na = mr(), wf = cr(), _f = Pn(), Pf = bt(), If = Pf("iterator");
                ua.exports = function(e) {
                    if (!wf(e)) return na(e, If) || na(e, "@@iterator") || _f[Nf(e)];
                };
            });
            var ia = xe((Ny, sa)=>{
                var kf = At(), Lf = Ht(), Of = Tt(), jf = Dr(), qf = In(), Mf = TypeError;
                sa.exports = function(e, r) {
                    var t1 = arguments.length < 2 ? qf(e) : r;
                    if (Lf(t1)) return Of(kf(t1, e));
                    throw Mf(jf(e) + " is not iterable");
                };
            });
            var la = xe((wy, oa)=>{
                var Rf = At(), aa = Tt(), $f = mr();
                oa.exports = function(e, r, t1) {
                    var s, a2;
                    aa(e);
                    try {
                        if (s = $f(e, "return"), !s) {
                            if (r === "throw") throw t1;
                            return t1;
                        }
                        s = Rf(s, e);
                    } catch (n) {
                        a2 = true, s = n;
                    }
                    if (r === "throw") throw t1;
                    if (a2) throw s;
                    return aa(s), t1;
                };
            });
            var ma = xe((_y, Da)=>{
                var Vf = Tn(), Wf = At(), Hf = Tt(), Gf = Dr(), Uf = ra(), Jf = Lt(), ca = Xr(), zf = ia(), Xf = In(), pa = la(), Kf = TypeError, br = function(e, r) {
                    this.stopped = e, this.result = r;
                }, fa = br.prototype;
                Da.exports = function(e, r, t1) {
                    var s = t1 && t1.that, a2 = !!(t1 && t1.AS_ENTRIES), n = !!(t1 && t1.IS_RECORD), u = !!(t1 && t1.IS_ITERATOR), i = !!(t1 && t1.INTERRUPTED), l = Vf(r, s), p, y, h, g, c, f2, F, _2 = function(E) {
                        return p && pa(p, "normal", E), new br(true, E);
                    }, w = function(E) {
                        return a2 ? (Hf(E), i ? l(E[0], E[1], _2) : l(E[0], E[1])) : i ? l(E, _2) : l(E);
                    };
                    if (n) p = e.iterator;
                    else if (u) p = e;
                    else {
                        if (y = Xf(e), !y) throw Kf(Gf(e) + " is not iterable");
                        if (Uf(y)) {
                            for(h = 0, g = Jf(e); g > h; h++)if (c = w(e[h]), c && ca(fa, c)) return c;
                            return new br(false);
                        }
                        p = zf(e, y);
                    }
                    for(f2 = n ? e.next : p.next; !(F = Wf(f2, p)).done;){
                        try {
                            c = w(F.value);
                        } catch (E) {
                            pa(p, "throw", E);
                        }
                        if (typeof c == "object" && c && ca(fa, c)) return c;
                    }
                    return new br(false);
                };
            });
            var ga = xe((Py, da)=>{
                "use strict";
                var Yf = hr(), Qf = kt(), Zf = lr();
                da.exports = function(e, r, t1) {
                    var s = Yf(r);
                    s in e ? Qf.f(e, s, Zf(0, t1)) : e[s] = t1;
                };
            });
            var ya = xe(()=>{
                var eD = Jt(), tD = ma(), rD = ga();
                eD({
                    target: "Object",
                    stat: true
                }, {
                    fromEntries: function(r) {
                        var t1 = {};
                        return tD(r, function(s, a2) {
                            rD(t1, s, a2);
                        }, {
                            AS_ENTRIES: true
                        }), t1;
                    }
                });
            });
            var Ca = xe((Ly, va)=>{
                var ha = An(), nD = kt();
                va.exports = function(e, r, t1) {
                    return t1.get && ha(t1.get, r, {
                        getter: true
                    }), t1.set && ha(t1.set, r, {
                        setter: true
                    }), nD.f(e, r, t1);
                };
            });
            var Fa = xe((Oy, Ea)=>{
                "use strict";
                var uD = Tt();
                Ea.exports = function() {
                    var e = uD(this), r = "";
                    return e.hasIndices && (r += "d"), e.global && (r += "g"), e.ignoreCase && (r += "i"), e.multiline && (r += "m"), e.dotAll && (r += "s"), e.unicode && (r += "u"), e.unicodeSets && (r += "v"), e.sticky && (r += "y"), r;
                };
            });
            var xa = xe(()=>{
                var sD = pt(), iD = yt(), aD = Ca(), oD = Fa(), lD = Dt(), Aa = sD.RegExp, Sa = Aa.prototype, cD = iD && lD(function() {
                    var e = true;
                    try {
                        Aa(".", "d");
                    } catch  {
                        e = false;
                    }
                    var r = {}, t1 = "", s = e ? "dgimsy" : "gimsy", a2 = function(l, p) {
                        Object.defineProperty(r, l, {
                            get: function() {
                                return t1 += p, true;
                            }
                        });
                    }, n = {
                        dotAll: "s",
                        global: "g",
                        ignoreCase: "i",
                        multiline: "m",
                        sticky: "y"
                    };
                    e && (n.hasIndices = "d");
                    for(var u in n)a2(u, n[u]);
                    var i = Object.getOwnPropertyDescriptor(Sa, "flags").get.call(r);
                    return i !== s || t1 !== s;
                });
                cD && aD(Sa, "flags", {
                    configurable: true,
                    get: oD
                });
            });
            var ba = xe(()=>{
                var pD = Jt(), kn = pt();
                pD({
                    global: true,
                    forced: kn.globalThis !== kn
                }, {
                    globalThis: kn
                });
            });
            var Ta = xe(()=>{
                ba();
            });
            var Ba = xe(()=>{
                "use strict";
                var fD = Jt(), DD = Bn(), mD = yr(), dD = Lt(), gD = Sr(), yD = _n();
                fD({
                    target: "Array",
                    proto: true
                }, {
                    flat: function() {
                        var r = arguments.length ? arguments[0] : void 0, t1 = mD(this), s = dD(t1), a2 = yD(t1, 0);
                        return a2.length = DD(a2, t1, t1, s, 0, r === void 0 ? 1 : gD(r)), a2;
                    }
                });
            });
            var e0 = xe((Uy, jo)=>{
                var hD = [
                    "cliName",
                    "cliCategory",
                    "cliDescription"
                ], vD = [
                    "_"
                ], CD = [
                    "languageId"
                ];
                function Hn(e, r) {
                    if (e == null) return {};
                    var t1 = ED(e, r), s, a2;
                    if (Object.getOwnPropertySymbols) {
                        var n = Object.getOwnPropertySymbols(e);
                        for(a2 = 0; a2 < n.length; a2++)s = n[a2], !(r.indexOf(s) >= 0) && Object.prototype.propertyIsEnumerable.call(e, s) && (t1[s] = e[s]);
                    }
                    return t1;
                }
                function ED(e, r) {
                    if (e == null) return {};
                    var t1 = {}, s = Object.keys(e), a2, n;
                    for(n = 0; n < s.length; n++)a2 = s[n], !(r.indexOf(a2) >= 0) && (t1[a2] = e[a2]);
                    return t1;
                }
                Zi();
                ya();
                xa();
                Ta();
                Ba();
                var FD = Object.create, _r = Object.defineProperty, AD = Object.getOwnPropertyDescriptor, Gn = Object.getOwnPropertyNames, SD = Object.getPrototypeOf, xD = Object.prototype.hasOwnProperty, ht = (e, r)=>function() {
                        return e && (r = (0, e[Gn(e)[0]])(e = 0)), r;
                    }, te = (e, r)=>function() {
                        return r || (0, e[Gn(e)[0]])((r = {
                            exports: {}
                        }).exports, r), r.exports;
                    }, Kt = (e, r)=>{
                    for(var t1 in r)_r(e, t1, {
                        get: r[t1],
                        enumerable: true
                    });
                }, Pa = (e, r, t1, s)=>{
                    if (r && typeof r == "object" || typeof r == "function") for (let a2 of Gn(r))!xD.call(e, a2) && a2 !== t1 && _r(e, a2, {
                        get: ()=>r[a2],
                        enumerable: !(s = AD(r, a2)) || s.enumerable
                    });
                    return e;
                }, bD = (e, r, t1)=>(t1 = e != null ? FD(SD(e)) : {}, Pa(r || !e || !e.__esModule ? _r(t1, "default", {
                        value: e,
                        enumerable: true
                    }) : t1, e)), ft = (e)=>Pa(_r({}, "__esModule", {
                        value: true
                    }), e), wt, ne = ht({
                    "<define:process>" () {
                        wt = {
                            env: {},
                            argv: []
                        };
                    }
                }), Ia = te({
                    "package.json" (e, r) {
                        r.exports = {
                            version: "2.8.8"
                        };
                    }
                }), TD = te({
                    "node_modules/diff/lib/diff/base.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        }), e.default = r;
                        function r() {}
                        r.prototype = {
                            diff: function(n, u) {
                                var i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, l = i.callback;
                                typeof i == "function" && (l = i, i = {}), this.options = i;
                                var p = this;
                                function y(N) {
                                    return l ? (setTimeout(function() {
                                        l(void 0, N);
                                    }, 0), true) : N;
                                }
                                n = this.castInput(n), u = this.castInput(u), n = this.removeEmpty(this.tokenize(n)), u = this.removeEmpty(this.tokenize(u));
                                var h = u.length, g = n.length, c = 1, f2 = h + g, F = [
                                    {
                                        newPos: -1,
                                        components: []
                                    }
                                ], _2 = this.extractCommon(F[0], u, n, 0);
                                if (F[0].newPos + 1 >= h && _2 + 1 >= g) return y([
                                    {
                                        value: this.join(u),
                                        count: u.length
                                    }
                                ]);
                                function w() {
                                    for(var N = -1 * c; N <= c; N += 2){
                                        var x = void 0, I = F[N - 1], P = F[N + 1], $ = (P ? P.newPos : 0) - N;
                                        I && (F[N - 1] = void 0);
                                        var D = I && I.newPos + 1 < h, T = P && 0 <= $ && $ < g;
                                        if (!D && !T) {
                                            F[N] = void 0;
                                            continue;
                                        }
                                        if (!D || T && I.newPos < P.newPos ? (x = s(P), p.pushComponent(x.components, void 0, true)) : (x = I, x.newPos++, p.pushComponent(x.components, true, void 0)), $ = p.extractCommon(x, u, n, N), x.newPos + 1 >= h && $ + 1 >= g) return y(t1(p, x.components, u, n, p.useLongestToken));
                                        F[N] = x;
                                    }
                                    c++;
                                }
                                if (l) (function N() {
                                    setTimeout(function() {
                                        if (c > f2) return l();
                                        w() || N();
                                    }, 0);
                                })();
                                else for(; c <= f2;){
                                    var E = w();
                                    if (E) return E;
                                }
                            },
                            pushComponent: function(n, u, i) {
                                var l = n[n.length - 1];
                                l && l.added === u && l.removed === i ? n[n.length - 1] = {
                                    count: l.count + 1,
                                    added: u,
                                    removed: i
                                } : n.push({
                                    count: 1,
                                    added: u,
                                    removed: i
                                });
                            },
                            extractCommon: function(n, u, i, l) {
                                for(var p = u.length, y = i.length, h = n.newPos, g = h - l, c = 0; h + 1 < p && g + 1 < y && this.equals(u[h + 1], i[g + 1]);)h++, g++, c++;
                                return c && n.components.push({
                                    count: c
                                }), n.newPos = h, g;
                            },
                            equals: function(n, u) {
                                return this.options.comparator ? this.options.comparator(n, u) : n === u || this.options.ignoreCase && n.toLowerCase() === u.toLowerCase();
                            },
                            removeEmpty: function(n) {
                                for(var u = [], i = 0; i < n.length; i++)n[i] && u.push(n[i]);
                                return u;
                            },
                            castInput: function(n) {
                                return n;
                            },
                            tokenize: function(n) {
                                return n.split("");
                            },
                            join: function(n) {
                                return n.join("");
                            }
                        };
                        function t1(a2, n, u, i, l) {
                            for(var p = 0, y = n.length, h = 0, g = 0; p < y; p++){
                                var c = n[p];
                                if (c.removed) {
                                    if (c.value = a2.join(i.slice(g, g + c.count)), g += c.count, p && n[p - 1].added) {
                                        var F = n[p - 1];
                                        n[p - 1] = n[p], n[p] = F;
                                    }
                                } else {
                                    if (!c.added && l) {
                                        var f2 = u.slice(h, h + c.count);
                                        f2 = f2.map(function(w, E) {
                                            var N = i[g + E];
                                            return N.length > w.length ? N : w;
                                        }), c.value = a2.join(f2);
                                    } else c.value = a2.join(u.slice(h, h + c.count));
                                    h += c.count, c.added || (g += c.count);
                                }
                            }
                            var _2 = n[y - 1];
                            return y > 1 && typeof _2.value == "string" && (_2.added || _2.removed) && a2.equals("", _2.value) && (n[y - 2].value += _2.value, n.pop()), n;
                        }
                        function s(a2) {
                            return {
                                newPos: a2.newPos,
                                components: a2.components.slice(0)
                            };
                        }
                    }
                }), BD = te({
                    "node_modules/diff/lib/diff/array.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        }), e.diffArrays = a2, e.arrayDiff = void 0;
                        var r = t1(TD());
                        function t1(n) {
                            return n && n.__esModule ? n : {
                                default: n
                            };
                        }
                        var s = new r.default();
                        e.arrayDiff = s, s.tokenize = function(n) {
                            return n.slice();
                        }, s.join = s.removeEmpty = function(n) {
                            return n;
                        };
                        function a2(n, u, i) {
                            return s.diff(n, u, i);
                        }
                    }
                }), Un = te({
                    "src/document/doc-builders.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(C) {
                            return {
                                type: "concat",
                                parts: C
                            };
                        }
                        function s(C) {
                            return {
                                type: "indent",
                                contents: C
                            };
                        }
                        function a2(C, o) {
                            return {
                                type: "align",
                                contents: o,
                                n: C
                            };
                        }
                        function n(C) {
                            let o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
                            return {
                                type: "group",
                                id: o.id,
                                contents: C,
                                break: Boolean(o.shouldBreak),
                                expandedStates: o.expandedStates
                            };
                        }
                        function u(C) {
                            return a2(Number.NEGATIVE_INFINITY, C);
                        }
                        function i(C) {
                            return a2({
                                type: "root"
                            }, C);
                        }
                        function l(C) {
                            return a2(-1, C);
                        }
                        function p(C, o) {
                            return n(C[0], Object.assign(Object.assign({}, o), {}, {
                                expandedStates: C
                            }));
                        }
                        function y(C) {
                            return {
                                type: "fill",
                                parts: C
                            };
                        }
                        function h(C, o) {
                            let d = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
                            return {
                                type: "if-break",
                                breakContents: C,
                                flatContents: o,
                                groupId: d.groupId
                            };
                        }
                        function g(C, o) {
                            return {
                                type: "indent-if-break",
                                contents: C,
                                groupId: o.groupId,
                                negate: o.negate
                            };
                        }
                        function c(C) {
                            return {
                                type: "line-suffix",
                                contents: C
                            };
                        }
                        var f2 = {
                            type: "line-suffix-boundary"
                        }, F = {
                            type: "break-parent"
                        }, _2 = {
                            type: "trim"
                        }, w = {
                            type: "line",
                            hard: true
                        }, E = {
                            type: "line",
                            hard: true,
                            literal: true
                        }, N = {
                            type: "line"
                        }, x = {
                            type: "line",
                            soft: true
                        }, I = t1([
                            w,
                            F
                        ]), P = t1([
                            E,
                            F
                        ]), $ = {
                            type: "cursor",
                            placeholder: Symbol("cursor")
                        };
                        function D(C, o) {
                            let d = [];
                            for(let v = 0; v < o.length; v++)v !== 0 && d.push(C), d.push(o[v]);
                            return t1(d);
                        }
                        function T(C, o, d) {
                            let v = C;
                            if (o > 0) {
                                for(let S = 0; S < Math.floor(o / d); ++S)v = s(v);
                                v = a2(o % d, v), v = a2(Number.NEGATIVE_INFINITY, v);
                            }
                            return v;
                        }
                        function m(C, o) {
                            return {
                                type: "label",
                                label: C,
                                contents: o
                            };
                        }
                        r.exports = {
                            concat: t1,
                            join: D,
                            line: N,
                            softline: x,
                            hardline: I,
                            literalline: P,
                            group: n,
                            conditionalGroup: p,
                            fill: y,
                            lineSuffix: c,
                            lineSuffixBoundary: f2,
                            cursor: $,
                            breakParent: F,
                            ifBreak: h,
                            trim: _2,
                            indent: s,
                            indentIfBreak: g,
                            align: a2,
                            addAlignmentToDoc: T,
                            markAsRoot: i,
                            dedentToRoot: u,
                            dedent: l,
                            hardlineWithoutBreakParent: w,
                            literallineWithoutBreakParent: E,
                            label: m
                        };
                    }
                }), Jn = te({
                    "src/common/end-of-line.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(u) {
                            let i = u.indexOf("\r");
                            return i >= 0 ? u.charAt(i + 1) === `
` ? "crlf" : "cr" : "lf";
                        }
                        function s(u) {
                            switch(u){
                                case "cr":
                                    return "\r";
                                case "crlf":
                                    return `\r
`;
                                default:
                                    return `
`;
                            }
                        }
                        function a2(u, i) {
                            let l;
                            switch(i){
                                case `
`:
                                    l = /\n/g;
                                    break;
                                case "\r":
                                    l = /\r/g;
                                    break;
                                case `\r
`:
                                    l = /\r\n/g;
                                    break;
                                default:
                                    throw new Error(`Unexpected "eol" ${JSON.stringify(i)}.`);
                            }
                            let p = u.match(l);
                            return p ? p.length : 0;
                        }
                        function n(u) {
                            return u.replace(/\r\n?/g, `
`);
                        }
                        r.exports = {
                            guessEndOfLine: t1,
                            convertEndOfLineToChars: s,
                            countEndOfLineChars: a2,
                            normalizeEndOfLine: n
                        };
                    }
                }), lt = te({
                    "src/utils/get-last.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = (s)=>s[s.length - 1];
                        r.exports = t1;
                    }
                });
                function ND() {
                    let { onlyFirst: e = false } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, r = [
                        "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
                        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
                    ].join("|");
                    return new RegExp(r, e ? void 0 : "g");
                }
                var wD = ht({
                    "node_modules/strip-ansi/node_modules/ansi-regex/index.js" () {
                        ne();
                    }
                });
                function _D(e) {
                    if (typeof e != "string") throw new TypeError(`Expected a \`string\`, got \`${typeof e}\``);
                    return e.replace(ND(), "");
                }
                var PD = ht({
                    "node_modules/strip-ansi/index.js" () {
                        ne(), wD();
                    }
                });
                function ID(e) {
                    return Number.isInteger(e) ? e >= 4352 && (e <= 4447 || e === 9001 || e === 9002 || 11904 <= e && e <= 12871 && e !== 12351 || 12880 <= e && e <= 19903 || 19968 <= e && e <= 42182 || 43360 <= e && e <= 43388 || 44032 <= e && e <= 55203 || 63744 <= e && e <= 64255 || 65040 <= e && e <= 65049 || 65072 <= e && e <= 65131 || 65281 <= e && e <= 65376 || 65504 <= e && e <= 65510 || 110592 <= e && e <= 110593 || 127488 <= e && e <= 127569 || 131072 <= e && e <= 262141) : false;
                }
                var kD = ht({
                    "node_modules/is-fullwidth-code-point/index.js" () {
                        ne();
                    }
                }), LD = te({
                    "node_modules/emoji-regex/index.js" (e, r) {
                        "use strict";
                        ne(), r.exports = function() {
                            return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67)\uDB40\uDC7F|(?:\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFC-\uDFFF])|\uD83D\uDC68(?:\uD83C\uDFFB(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|[\u2695\u2696\u2708]\uFE0F|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))?|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])\uFE0F|\u200D(?:(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D[\uDC66\uDC67])|\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC)?|(?:\uD83D\uDC69(?:\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69]))|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC69(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83E\uDDD1(?:\u200D(?:\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDE36\u200D\uD83C\uDF2B|\uD83C\uDFF3\uFE0F\u200D\u26A7|\uD83D\uDC3B\u200D\u2744|(?:(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\uD83C\uDFF4\u200D\u2620|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])\u200D[\u2640\u2642]|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u2600-\u2604\u260E\u2611\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26B0\u26B1\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0\u26F1\u26F4\u26F7\u26F8\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u3030\u303D\u3297\u3299]|\uD83C[\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]|\uD83D[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3])\uFE0F|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDE35\u200D\uD83D\uDCAB|\uD83D\uDE2E\u200D\uD83D\uDCA8|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83E\uDDD1(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83D\uDC69(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF6\uD83C\uDDE6|\uD83C\uDDF4\uD83C\uDDF2|\uD83D\uDC08\u200D\u2B1B|\u2764\uFE0F\u200D(?:\uD83D\uDD25|\uD83E\uDE79)|\uD83D\uDC41\uFE0F|\uD83C\uDFF3\uFE0F|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|[#\*0-9]\uFE0F\u20E3|\u2764\uFE0F|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|\uD83C\uDFF4|(?:[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270C\u270D]|\uD83D[\uDD74\uDD90])(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC08\uDC15\uDC3B\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE2E\uDE35\uDE36\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5]|\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD]|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF]|[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0D\uDD0E\uDD10-\uDD17\uDD1D\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78\uDD7A-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCB\uDDD0\uDDE0-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6]|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26A7\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5-\uDED7\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDD77\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
                        };
                    }
                }), ka = {};
                Kt(ka, {
                    default: ()=>OD
                });
                function OD(e) {
                    if (typeof e != "string" || e.length === 0 || (e = _D(e), e.length === 0)) return 0;
                    e = e.replace((0, La.default)(), "  ");
                    let r = 0;
                    for(let t1 = 0; t1 < e.length; t1++){
                        let s = e.codePointAt(t1);
                        s <= 31 || s >= 127 && s <= 159 || s >= 768 && s <= 879 || (s > 65535 && t1++, r += ID(s) ? 2 : 1);
                    }
                    return r;
                }
                var La, jD = ht({
                    "node_modules/string-width/index.js" () {
                        ne(), PD(), kD(), La = bD(LD());
                    }
                }), Oa = te({
                    "src/utils/get-string-width.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = (jD(), ft(ka)).default, s = /[^\x20-\x7F]/;
                        function a2(n) {
                            return n ? s.test(n) ? t1(n) : n.length : 0;
                        }
                        r.exports = a2;
                    }
                }), Yt = te({
                    "src/document/doc-utils.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = lt(), { literalline: s, join: a2 } = Un(), n = (o)=>Array.isArray(o) || o && o.type === "concat", u = (o)=>{
                            if (Array.isArray(o)) return o;
                            if (o.type !== "concat" && o.type !== "fill") throw new Error("Expect doc type to be `concat` or `fill`.");
                            return o.parts;
                        }, i = {};
                        function l(o, d, v, S) {
                            let b = [
                                o
                            ];
                            for(; b.length > 0;){
                                let B = b.pop();
                                if (B === i) {
                                    v(b.pop());
                                    continue;
                                }
                                if (v && b.push(B, i), !d || d(B) !== false) if (n(B) || B.type === "fill") {
                                    let k = u(B);
                                    for(let M = k.length, R = M - 1; R >= 0; --R)b.push(k[R]);
                                } else if (B.type === "if-break") B.flatContents && b.push(B.flatContents), B.breakContents && b.push(B.breakContents);
                                else if (B.type === "group" && B.expandedStates) if (S) for(let k = B.expandedStates.length, M = k - 1; M >= 0; --M)b.push(B.expandedStates[M]);
                                else b.push(B.contents);
                                else B.contents && b.push(B.contents);
                            }
                        }
                        function p(o, d) {
                            let v = /* @__PURE__ */ new Map();
                            return S(o);
                            function S(B) {
                                if (v.has(B)) return v.get(B);
                                let k = b(B);
                                return v.set(B, k), k;
                            }
                            function b(B) {
                                if (Array.isArray(B)) return d(B.map(S));
                                if (B.type === "concat" || B.type === "fill") {
                                    let k = B.parts.map(S);
                                    return d(Object.assign(Object.assign({}, B), {}, {
                                        parts: k
                                    }));
                                }
                                if (B.type === "if-break") {
                                    let k = B.breakContents && S(B.breakContents), M = B.flatContents && S(B.flatContents);
                                    return d(Object.assign(Object.assign({}, B), {}, {
                                        breakContents: k,
                                        flatContents: M
                                    }));
                                }
                                if (B.type === "group" && B.expandedStates) {
                                    let k = B.expandedStates.map(S), M = k[0];
                                    return d(Object.assign(Object.assign({}, B), {}, {
                                        contents: M,
                                        expandedStates: k
                                    }));
                                }
                                if (B.contents) {
                                    let k = S(B.contents);
                                    return d(Object.assign(Object.assign({}, B), {}, {
                                        contents: k
                                    }));
                                }
                                return d(B);
                            }
                        }
                        function y(o, d, v) {
                            let S = v, b = false;
                            function B(k) {
                                let M = d(k);
                                if (M !== void 0 && (b = true, S = M), b) return false;
                            }
                            return l(o, B), S;
                        }
                        function h(o) {
                            if (o.type === "group" && o.break || o.type === "line" && o.hard || o.type === "break-parent") return true;
                        }
                        function g(o) {
                            return y(o, h, false);
                        }
                        function c(o) {
                            if (o.length > 0) {
                                let d = t1(o);
                                !d.expandedStates && !d.break && (d.break = "propagated");
                            }
                            return null;
                        }
                        function f2(o) {
                            let d = /* @__PURE__ */ new Set(), v = [];
                            function S(B) {
                                if (B.type === "break-parent" && c(v), B.type === "group") {
                                    if (v.push(B), d.has(B)) return false;
                                    d.add(B);
                                }
                            }
                            function b(B) {
                                B.type === "group" && v.pop().break && c(v);
                            }
                            l(o, S, b, true);
                        }
                        function F(o) {
                            return o.type === "line" && !o.hard ? o.soft ? "" : " " : o.type === "if-break" ? o.flatContents || "" : o;
                        }
                        function _2(o) {
                            return p(o, F);
                        }
                        var w = (o, d)=>o && o.type === "line" && o.hard && d && d.type === "break-parent";
                        function E(o) {
                            if (!o) return o;
                            if (n(o) || o.type === "fill") {
                                let d = u(o);
                                for(; d.length > 1 && w(...d.slice(-2));)d.length -= 2;
                                if (d.length > 0) {
                                    let v = E(t1(d));
                                    d[d.length - 1] = v;
                                }
                                return Array.isArray(o) ? d : Object.assign(Object.assign({}, o), {}, {
                                    parts: d
                                });
                            }
                            switch(o.type){
                                case "align":
                                case "indent":
                                case "indent-if-break":
                                case "group":
                                case "line-suffix":
                                case "label":
                                    {
                                        let d = E(o.contents);
                                        return Object.assign(Object.assign({}, o), {}, {
                                            contents: d
                                        });
                                    }
                                case "if-break":
                                    {
                                        let d = E(o.breakContents), v = E(o.flatContents);
                                        return Object.assign(Object.assign({}, o), {}, {
                                            breakContents: d,
                                            flatContents: v
                                        });
                                    }
                            }
                            return o;
                        }
                        function N(o) {
                            return E(I(o));
                        }
                        function x(o) {
                            switch(o.type){
                                case "fill":
                                    if (o.parts.every((v)=>v === "")) return "";
                                    break;
                                case "group":
                                    if (!o.contents && !o.id && !o.break && !o.expandedStates) return "";
                                    if (o.contents.type === "group" && o.contents.id === o.id && o.contents.break === o.break && o.contents.expandedStates === o.expandedStates) return o.contents;
                                    break;
                                case "align":
                                case "indent":
                                case "indent-if-break":
                                case "line-suffix":
                                    if (!o.contents) return "";
                                    break;
                                case "if-break":
                                    if (!o.flatContents && !o.breakContents) return "";
                                    break;
                            }
                            if (!n(o)) return o;
                            let d = [];
                            for (let v of u(o)){
                                if (!v) continue;
                                let [S, ...b] = n(v) ? u(v) : [
                                    v
                                ];
                                typeof S == "string" && typeof t1(d) == "string" ? d[d.length - 1] += S : d.push(S), d.push(...b);
                            }
                            return d.length === 0 ? "" : d.length === 1 ? d[0] : Array.isArray(o) ? d : Object.assign(Object.assign({}, o), {}, {
                                parts: d
                            });
                        }
                        function I(o) {
                            return p(o, (d)=>x(d));
                        }
                        function P(o) {
                            let d = [], v = o.filter(Boolean);
                            for(; v.length > 0;){
                                let S = v.shift();
                                if (S) {
                                    if (n(S)) {
                                        v.unshift(...u(S));
                                        continue;
                                    }
                                    if (d.length > 0 && typeof t1(d) == "string" && typeof S == "string") {
                                        d[d.length - 1] += S;
                                        continue;
                                    }
                                    d.push(S);
                                }
                            }
                            return d;
                        }
                        function $(o) {
                            return p(o, (d)=>Array.isArray(d) ? P(d) : d.parts ? Object.assign(Object.assign({}, d), {}, {
                                    parts: P(d.parts)
                                }) : d);
                        }
                        function D(o) {
                            return p(o, (d)=>typeof d == "string" && d.includes(`
`) ? T(d) : d);
                        }
                        function T(o) {
                            let d = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : s;
                            return a2(d, o.split(`
`)).parts;
                        }
                        function m(o) {
                            if (o.type === "line") return true;
                        }
                        function C(o) {
                            return y(o, m, false);
                        }
                        r.exports = {
                            isConcat: n,
                            getDocParts: u,
                            willBreak: g,
                            traverseDoc: l,
                            findInDoc: y,
                            mapDoc: p,
                            propagateBreaks: f2,
                            removeLines: _2,
                            stripTrailingHardline: N,
                            normalizeParts: P,
                            normalizeDoc: $,
                            cleanDoc: I,
                            replaceTextEndOfLine: T,
                            replaceEndOfLine: D,
                            canBreak: C
                        };
                    }
                }), qD = te({
                    "src/document/doc-printer.js" (e, r) {
                        "use strict";
                        ne();
                        var { convertEndOfLineToChars: t1 } = Jn(), s = lt(), a2 = Oa(), { fill: n, cursor: u, indent: i } = Un(), { isConcat: l, getDocParts: p } = Yt(), y, h = 1, g = 2;
                        function c() {
                            return {
                                value: "",
                                length: 0,
                                queue: []
                            };
                        }
                        function f2(x, I) {
                            return _2(x, {
                                type: "indent"
                            }, I);
                        }
                        function F(x, I, P) {
                            return I === Number.NEGATIVE_INFINITY ? x.root || c() : I < 0 ? _2(x, {
                                type: "dedent"
                            }, P) : I ? I.type === "root" ? Object.assign(Object.assign({}, x), {}, {
                                root: x
                            }) : _2(x, {
                                type: typeof I == "string" ? "stringAlign" : "numberAlign",
                                n: I
                            }, P) : x;
                        }
                        function _2(x, I, P) {
                            let $ = I.type === "dedent" ? x.queue.slice(0, -1) : [
                                ...x.queue,
                                I
                            ], D = "", T = 0, m = 0, C = 0;
                            for (let k of $)switch(k.type){
                                case "indent":
                                    v(), P.useTabs ? o(1) : d(P.tabWidth);
                                    break;
                                case "stringAlign":
                                    v(), D += k.n, T += k.n.length;
                                    break;
                                case "numberAlign":
                                    m += 1, C += k.n;
                                    break;
                                default:
                                    throw new Error(`Unexpected type '${k.type}'`);
                            }
                            return b(), Object.assign(Object.assign({}, x), {}, {
                                value: D,
                                length: T,
                                queue: $
                            });
                            function o(k) {
                                D += "	".repeat(k), T += P.tabWidth * k;
                            }
                            function d(k) {
                                D += " ".repeat(k), T += k;
                            }
                            function v() {
                                P.useTabs ? S() : b();
                            }
                            function S() {
                                m > 0 && o(m), B();
                            }
                            function b() {
                                C > 0 && d(C), B();
                            }
                            function B() {
                                m = 0, C = 0;
                            }
                        }
                        function w(x) {
                            if (x.length === 0) return 0;
                            let I = 0;
                            for(; x.length > 0 && typeof s(x) == "string" && /^[\t ]*$/.test(s(x));)I += x.pop().length;
                            if (x.length > 0 && typeof s(x) == "string") {
                                let P = s(x).replace(/[\t ]*$/, "");
                                I += s(x).length - P.length, x[x.length - 1] = P;
                            }
                            return I;
                        }
                        function E(x, I, P, $, D) {
                            let T = I.length, m = [
                                x
                            ], C = [];
                            for(; P >= 0;){
                                if (m.length === 0) {
                                    if (T === 0) return true;
                                    m.push(I[--T]);
                                    continue;
                                }
                                let { mode: o, doc: d } = m.pop();
                                if (typeof d == "string") C.push(d), P -= a2(d);
                                else if (l(d) || d.type === "fill") {
                                    let v = p(d);
                                    for(let S = v.length - 1; S >= 0; S--)m.push({
                                        mode: o,
                                        doc: v[S]
                                    });
                                } else switch(d.type){
                                    case "indent":
                                    case "align":
                                    case "indent-if-break":
                                    case "label":
                                        m.push({
                                            mode: o,
                                            doc: d.contents
                                        });
                                        break;
                                    case "trim":
                                        P += w(C);
                                        break;
                                    case "group":
                                        {
                                            if (D && d.break) return false;
                                            let v = d.break ? h : o, S = d.expandedStates && v === h ? s(d.expandedStates) : d.contents;
                                            m.push({
                                                mode: v,
                                                doc: S
                                            });
                                            break;
                                        }
                                    case "if-break":
                                        {
                                            let S = (d.groupId ? y[d.groupId] || g : o) === h ? d.breakContents : d.flatContents;
                                            S && m.push({
                                                mode: o,
                                                doc: S
                                            });
                                            break;
                                        }
                                    case "line":
                                        if (o === h || d.hard) return true;
                                        d.soft || (C.push(" "), P--);
                                        break;
                                    case "line-suffix":
                                        $ = true;
                                        break;
                                    case "line-suffix-boundary":
                                        if ($) return false;
                                        break;
                                }
                            }
                            return false;
                        }
                        function N(x, I) {
                            y = {};
                            let P = I.printWidth, $ = t1(I.endOfLine), D = 0, T = [
                                {
                                    ind: c(),
                                    mode: h,
                                    doc: x
                                }
                            ], m = [], C = false, o = [];
                            for(; T.length > 0;){
                                let { ind: v, mode: S, doc: b } = T.pop();
                                if (typeof b == "string") {
                                    let B = $ !== `
` ? b.replace(/\n/g, $) : b;
                                    m.push(B), D += a2(B);
                                } else if (l(b)) {
                                    let B = p(b);
                                    for(let k = B.length - 1; k >= 0; k--)T.push({
                                        ind: v,
                                        mode: S,
                                        doc: B[k]
                                    });
                                } else switch(b.type){
                                    case "cursor":
                                        m.push(u.placeholder);
                                        break;
                                    case "indent":
                                        T.push({
                                            ind: f2(v, I),
                                            mode: S,
                                            doc: b.contents
                                        });
                                        break;
                                    case "align":
                                        T.push({
                                            ind: F(v, b.n, I),
                                            mode: S,
                                            doc: b.contents
                                        });
                                        break;
                                    case "trim":
                                        D -= w(m);
                                        break;
                                    case "group":
                                        switch(S){
                                            case g:
                                                if (!C) {
                                                    T.push({
                                                        ind: v,
                                                        mode: b.break ? h : g,
                                                        doc: b.contents
                                                    });
                                                    break;
                                                }
                                            case h:
                                                {
                                                    C = false;
                                                    let B = {
                                                        ind: v,
                                                        mode: g,
                                                        doc: b.contents
                                                    }, k = P - D, M = o.length > 0;
                                                    if (!b.break && E(B, T, k, M)) T.push(B);
                                                    else if (b.expandedStates) {
                                                        let R = s(b.expandedStates);
                                                        if (b.break) {
                                                            T.push({
                                                                ind: v,
                                                                mode: h,
                                                                doc: R
                                                            });
                                                            break;
                                                        } else for(let q = 1; q < b.expandedStates.length + 1; q++)if (q >= b.expandedStates.length) {
                                                            T.push({
                                                                ind: v,
                                                                mode: h,
                                                                doc: R
                                                            });
                                                            break;
                                                        } else {
                                                            let J = b.expandedStates[q], L = {
                                                                ind: v,
                                                                mode: g,
                                                                doc: J
                                                            };
                                                            if (E(L, T, k, M)) {
                                                                T.push(L);
                                                                break;
                                                            }
                                                        }
                                                    } else T.push({
                                                        ind: v,
                                                        mode: h,
                                                        doc: b.contents
                                                    });
                                                    break;
                                                }
                                        }
                                        b.id && (y[b.id] = s(T).mode);
                                        break;
                                    case "fill":
                                        {
                                            let B = P - D, { parts: k } = b;
                                            if (k.length === 0) break;
                                            let [M, R] = k, q = {
                                                ind: v,
                                                mode: g,
                                                doc: M
                                            }, J = {
                                                ind: v,
                                                mode: h,
                                                doc: M
                                            }, L = E(q, [], B, o.length > 0, true);
                                            if (k.length === 1) {
                                                L ? T.push(q) : T.push(J);
                                                break;
                                            }
                                            let Q = {
                                                ind: v,
                                                mode: g,
                                                doc: R
                                            }, V = {
                                                ind: v,
                                                mode: h,
                                                doc: R
                                            };
                                            if (k.length === 2) {
                                                L ? T.push(Q, q) : T.push(V, J);
                                                break;
                                            }
                                            k.splice(0, 2);
                                            let j = {
                                                ind: v,
                                                mode: S,
                                                doc: n(k)
                                            }, Y = k[0];
                                            E({
                                                ind: v,
                                                mode: g,
                                                doc: [
                                                    M,
                                                    R,
                                                    Y
                                                ]
                                            }, [], B, o.length > 0, true) ? T.push(j, Q, q) : L ? T.push(j, V, q) : T.push(j, V, J);
                                            break;
                                        }
                                    case "if-break":
                                    case "indent-if-break":
                                        {
                                            let B = b.groupId ? y[b.groupId] : S;
                                            if (B === h) {
                                                let k = b.type === "if-break" ? b.breakContents : b.negate ? b.contents : i(b.contents);
                                                k && T.push({
                                                    ind: v,
                                                    mode: S,
                                                    doc: k
                                                });
                                            }
                                            if (B === g) {
                                                let k = b.type === "if-break" ? b.flatContents : b.negate ? i(b.contents) : b.contents;
                                                k && T.push({
                                                    ind: v,
                                                    mode: S,
                                                    doc: k
                                                });
                                            }
                                            break;
                                        }
                                    case "line-suffix":
                                        o.push({
                                            ind: v,
                                            mode: S,
                                            doc: b.contents
                                        });
                                        break;
                                    case "line-suffix-boundary":
                                        o.length > 0 && T.push({
                                            ind: v,
                                            mode: S,
                                            doc: {
                                                type: "line",
                                                hard: true
                                            }
                                        });
                                        break;
                                    case "line":
                                        switch(S){
                                            case g:
                                                if (b.hard) C = true;
                                                else {
                                                    b.soft || (m.push(" "), D += 1);
                                                    break;
                                                }
                                            case h:
                                                if (o.length > 0) {
                                                    T.push({
                                                        ind: v,
                                                        mode: S,
                                                        doc: b
                                                    }, ...o.reverse()), o.length = 0;
                                                    break;
                                                }
                                                b.literal ? v.root ? (m.push($, v.root.value), D = v.root.length) : (m.push($), D = 0) : (D -= w(m), m.push($ + v.value), D = v.length);
                                                break;
                                        }
                                        break;
                                    case "label":
                                        T.push({
                                            ind: v,
                                            mode: S,
                                            doc: b.contents
                                        });
                                        break;
                                    default:
                                }
                                T.length === 0 && o.length > 0 && (T.push(...o.reverse()), o.length = 0);
                            }
                            let d = m.indexOf(u.placeholder);
                            if (d !== -1) {
                                let v = m.indexOf(u.placeholder, d + 1), S = m.slice(0, d).join(""), b = m.slice(d + 1, v).join(""), B = m.slice(v + 1).join("");
                                return {
                                    formatted: S + b + B,
                                    cursorNodeStart: S.length,
                                    cursorNodeText: b
                                };
                            }
                            return {
                                formatted: m.join("")
                            };
                        }
                        r.exports = {
                            printDocToString: N
                        };
                    }
                }), MD = te({
                    "src/document/doc-debug.js" (e, r) {
                        "use strict";
                        ne();
                        var { isConcat: t1, getDocParts: s } = Yt();
                        function a2(u) {
                            if (!u) return "";
                            if (t1(u)) {
                                let i = [];
                                for (let l of s(u))if (t1(l)) i.push(...a2(l).parts);
                                else {
                                    let p = a2(l);
                                    p !== "" && i.push(p);
                                }
                                return {
                                    type: "concat",
                                    parts: i
                                };
                            }
                            return u.type === "if-break" ? Object.assign(Object.assign({}, u), {}, {
                                breakContents: a2(u.breakContents),
                                flatContents: a2(u.flatContents)
                            }) : u.type === "group" ? Object.assign(Object.assign({}, u), {}, {
                                contents: a2(u.contents),
                                expandedStates: u.expandedStates && u.expandedStates.map(a2)
                            }) : u.type === "fill" ? {
                                type: "fill",
                                parts: u.parts.map(a2)
                            } : u.contents ? Object.assign(Object.assign({}, u), {}, {
                                contents: a2(u.contents)
                            }) : u;
                        }
                        function n(u) {
                            let i = /* @__PURE__ */ Object.create(null), l = /* @__PURE__ */ new Set();
                            return p(a2(u));
                            function p(h, g, c) {
                                if (typeof h == "string") return JSON.stringify(h);
                                if (t1(h)) {
                                    let f2 = s(h).map(p).filter(Boolean);
                                    return f2.length === 1 ? f2[0] : `[${f2.join(", ")}]`;
                                }
                                if (h.type === "line") {
                                    let f2 = Array.isArray(c) && c[g + 1] && c[g + 1].type === "break-parent";
                                    return h.literal ? f2 ? "literalline" : "literallineWithoutBreakParent" : h.hard ? f2 ? "hardline" : "hardlineWithoutBreakParent" : h.soft ? "softline" : "line";
                                }
                                if (h.type === "break-parent") return Array.isArray(c) && c[g - 1] && c[g - 1].type === "line" && c[g - 1].hard ? void 0 : "breakParent";
                                if (h.type === "trim") return "trim";
                                if (h.type === "indent") return "indent(" + p(h.contents) + ")";
                                if (h.type === "align") return h.n === Number.NEGATIVE_INFINITY ? "dedentToRoot(" + p(h.contents) + ")" : h.n < 0 ? "dedent(" + p(h.contents) + ")" : h.n.type === "root" ? "markAsRoot(" + p(h.contents) + ")" : "align(" + JSON.stringify(h.n) + ", " + p(h.contents) + ")";
                                if (h.type === "if-break") return "ifBreak(" + p(h.breakContents) + (h.flatContents ? ", " + p(h.flatContents) : "") + (h.groupId ? (h.flatContents ? "" : ', ""') + `, { groupId: ${y(h.groupId)} }` : "") + ")";
                                if (h.type === "indent-if-break") {
                                    let f2 = [];
                                    h.negate && f2.push("negate: true"), h.groupId && f2.push(`groupId: ${y(h.groupId)}`);
                                    let F = f2.length > 0 ? `, { ${f2.join(", ")} }` : "";
                                    return `indentIfBreak(${p(h.contents)}${F})`;
                                }
                                if (h.type === "group") {
                                    let f2 = [];
                                    h.break && h.break !== "propagated" && f2.push("shouldBreak: true"), h.id && f2.push(`id: ${y(h.id)}`);
                                    let F = f2.length > 0 ? `, { ${f2.join(", ")} }` : "";
                                    return h.expandedStates ? `conditionalGroup([${h.expandedStates.map((_2)=>p(_2)).join(",")}]${F})` : `group(${p(h.contents)}${F})`;
                                }
                                if (h.type === "fill") return `fill([${h.parts.map((f2)=>p(f2)).join(", ")}])`;
                                if (h.type === "line-suffix") return "lineSuffix(" + p(h.contents) + ")";
                                if (h.type === "line-suffix-boundary") return "lineSuffixBoundary";
                                if (h.type === "label") return `label(${JSON.stringify(h.label)}, ${p(h.contents)})`;
                                throw new Error("Unknown doc type " + h.type);
                            }
                            function y(h) {
                                if (typeof h != "symbol") return JSON.stringify(String(h));
                                if (h in i) return i[h];
                                let g = String(h).slice(7, -1) || "symbol";
                                for(let c = 0;; c++){
                                    let f2 = g + (c > 0 ? ` #${c}` : "");
                                    if (!l.has(f2)) return l.add(f2), i[h] = `Symbol.for(${JSON.stringify(f2)})`;
                                }
                            }
                        }
                        r.exports = {
                            printDocToDebug: n
                        };
                    }
                }), qe = te({
                    "src/document/index.js" (e, r) {
                        "use strict";
                        ne(), r.exports = {
                            builders: Un(),
                            printer: qD(),
                            utils: Yt(),
                            debug: MD()
                        };
                    }
                }), ja = {};
                Kt(ja, {
                    default: ()=>RD
                });
                function RD(e) {
                    if (typeof e != "string") throw new TypeError("Expected a string");
                    return e.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
                }
                var $D = ht({
                    "node_modules/escape-string-regexp/index.js" () {
                        ne();
                    }
                }), qa = te({
                    "node_modules/semver/internal/debug.js" (e, r) {
                        ne();
                        var t1 = typeof wt == "object" && wt.env && wt.env.NODE_DEBUG && /\bsemver\b/i.test(wt.env.NODE_DEBUG) ? function() {
                            for(var s = arguments.length, a2 = new Array(s), n = 0; n < s; n++)a2[n] = arguments[n];
                            return console.error("SEMVER", ...a2);
                        } : ()=>{};
                        r.exports = t1;
                    }
                }), Ma = te({
                    "node_modules/semver/internal/constants.js" (e, r) {
                        ne();
                        var t1 = "2.0.0", s = 256, a2 = Number.MAX_SAFE_INTEGER || 9007199254740991, n = 16;
                        r.exports = {
                            SEMVER_SPEC_VERSION: t1,
                            MAX_LENGTH: s,
                            MAX_SAFE_INTEGER: a2,
                            MAX_SAFE_COMPONENT_LENGTH: n
                        };
                    }
                }), VD = te({
                    "node_modules/semver/internal/re.js" (e, r) {
                        ne();
                        var { MAX_SAFE_COMPONENT_LENGTH: t1 } = Ma(), s = qa();
                        e = r.exports = {};
                        var a2 = e.re = [], n = e.src = [], u = e.t = {}, i = 0, l = (p, y, h)=>{
                            let g = i++;
                            s(p, g, y), u[p] = g, n[g] = y, a2[g] = new RegExp(y, h ? "g" : void 0);
                        };
                        l("NUMERICIDENTIFIER", "0|[1-9]\\d*"), l("NUMERICIDENTIFIERLOOSE", "[0-9]+"), l("NONNUMERICIDENTIFIER", "\\d*[a-zA-Z-][a-zA-Z0-9-]*"), l("MAINVERSION", `(${n[u.NUMERICIDENTIFIER]})\\.(${n[u.NUMERICIDENTIFIER]})\\.(${n[u.NUMERICIDENTIFIER]})`), l("MAINVERSIONLOOSE", `(${n[u.NUMERICIDENTIFIERLOOSE]})\\.(${n[u.NUMERICIDENTIFIERLOOSE]})\\.(${n[u.NUMERICIDENTIFIERLOOSE]})`), l("PRERELEASEIDENTIFIER", `(?:${n[u.NUMERICIDENTIFIER]}|${n[u.NONNUMERICIDENTIFIER]})`), l("PRERELEASEIDENTIFIERLOOSE", `(?:${n[u.NUMERICIDENTIFIERLOOSE]}|${n[u.NONNUMERICIDENTIFIER]})`), l("PRERELEASE", `(?:-(${n[u.PRERELEASEIDENTIFIER]}(?:\\.${n[u.PRERELEASEIDENTIFIER]})*))`), l("PRERELEASELOOSE", `(?:-?(${n[u.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${n[u.PRERELEASEIDENTIFIERLOOSE]})*))`), l("BUILDIDENTIFIER", "[0-9A-Za-z-]+"), l("BUILD", `(?:\\+(${n[u.BUILDIDENTIFIER]}(?:\\.${n[u.BUILDIDENTIFIER]})*))`), l("FULLPLAIN", `v?${n[u.MAINVERSION]}${n[u.PRERELEASE]}?${n[u.BUILD]}?`), l("FULL", `^${n[u.FULLPLAIN]}$`), l("LOOSEPLAIN", `[v=\\s]*${n[u.MAINVERSIONLOOSE]}${n[u.PRERELEASELOOSE]}?${n[u.BUILD]}?`), l("LOOSE", `^${n[u.LOOSEPLAIN]}$`), l("GTLT", "((?:<|>)?=?)"), l("XRANGEIDENTIFIERLOOSE", `${n[u.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), l("XRANGEIDENTIFIER", `${n[u.NUMERICIDENTIFIER]}|x|X|\\*`), l("XRANGEPLAIN", `[v=\\s]*(${n[u.XRANGEIDENTIFIER]})(?:\\.(${n[u.XRANGEIDENTIFIER]})(?:\\.(${n[u.XRANGEIDENTIFIER]})(?:${n[u.PRERELEASE]})?${n[u.BUILD]}?)?)?`), l("XRANGEPLAINLOOSE", `[v=\\s]*(${n[u.XRANGEIDENTIFIERLOOSE]})(?:\\.(${n[u.XRANGEIDENTIFIERLOOSE]})(?:\\.(${n[u.XRANGEIDENTIFIERLOOSE]})(?:${n[u.PRERELEASELOOSE]})?${n[u.BUILD]}?)?)?`), l("XRANGE", `^${n[u.GTLT]}\\s*${n[u.XRANGEPLAIN]}$`), l("XRANGELOOSE", `^${n[u.GTLT]}\\s*${n[u.XRANGEPLAINLOOSE]}$`), l("COERCE", `(^|[^\\d])(\\d{1,${t1}})(?:\\.(\\d{1,${t1}}))?(?:\\.(\\d{1,${t1}}))?(?:$|[^\\d])`), l("COERCERTL", n[u.COERCE], true), l("LONETILDE", "(?:~>?)"), l("TILDETRIM", `(\\s*)${n[u.LONETILDE]}\\s+`, true), e.tildeTrimReplace = "$1~", l("TILDE", `^${n[u.LONETILDE]}${n[u.XRANGEPLAIN]}$`), l("TILDELOOSE", `^${n[u.LONETILDE]}${n[u.XRANGEPLAINLOOSE]}$`), l("LONECARET", "(?:\\^)"), l("CARETTRIM", `(\\s*)${n[u.LONECARET]}\\s+`, true), e.caretTrimReplace = "$1^", l("CARET", `^${n[u.LONECARET]}${n[u.XRANGEPLAIN]}$`), l("CARETLOOSE", `^${n[u.LONECARET]}${n[u.XRANGEPLAINLOOSE]}$`), l("COMPARATORLOOSE", `^${n[u.GTLT]}\\s*(${n[u.LOOSEPLAIN]})$|^$`), l("COMPARATOR", `^${n[u.GTLT]}\\s*(${n[u.FULLPLAIN]})$|^$`), l("COMPARATORTRIM", `(\\s*)${n[u.GTLT]}\\s*(${n[u.LOOSEPLAIN]}|${n[u.XRANGEPLAIN]})`, true), e.comparatorTrimReplace = "$1$2$3", l("HYPHENRANGE", `^\\s*(${n[u.XRANGEPLAIN]})\\s+-\\s+(${n[u.XRANGEPLAIN]})\\s*$`), l("HYPHENRANGELOOSE", `^\\s*(${n[u.XRANGEPLAINLOOSE]})\\s+-\\s+(${n[u.XRANGEPLAINLOOSE]})\\s*$`), l("STAR", "(<|>)?=?\\s*\\*"), l("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), l("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
                    }
                }), WD = te({
                    "node_modules/semver/internal/parse-options.js" (e, r) {
                        ne();
                        var t1 = [
                            "includePrerelease",
                            "loose",
                            "rtl"
                        ], s = (a2)=>a2 ? typeof a2 != "object" ? {
                                loose: true
                            } : t1.filter((n)=>a2[n]).reduce((n, u)=>(n[u] = true, n), {}) : {};
                        r.exports = s;
                    }
                }), HD = te({
                    "node_modules/semver/internal/identifiers.js" (e, r) {
                        ne();
                        var t1 = /^[0-9]+$/, s = (n, u)=>{
                            let i = t1.test(n), l = t1.test(u);
                            return i && l && (n = +n, u = +u), n === u ? 0 : i && !l ? -1 : l && !i ? 1 : n < u ? -1 : 1;
                        }, a2 = (n, u)=>s(u, n);
                        r.exports = {
                            compareIdentifiers: s,
                            rcompareIdentifiers: a2
                        };
                    }
                }), GD = te({
                    "node_modules/semver/classes/semver.js" (e, r) {
                        ne();
                        var t1 = qa(), { MAX_LENGTH: s, MAX_SAFE_INTEGER: a2 } = Ma(), { re: n, t: u } = VD(), i = WD(), { compareIdentifiers: l } = HD(), p = class {
                            format() {
                                return this.version = `${this.major}.${this.minor}.${this.patch}`, this.prerelease.length && (this.version += `-${this.prerelease.join(".")}`), this.version;
                            }
                            toString() {
                                return this.version;
                            }
                            compare(y) {
                                if (t1("SemVer.compare", this.version, this.options, y), !(y instanceof p)) {
                                    if (typeof y == "string" && y === this.version) return 0;
                                    y = new p(y, this.options);
                                }
                                return y.version === this.version ? 0 : this.compareMain(y) || this.comparePre(y);
                            }
                            compareMain(y) {
                                return y instanceof p || (y = new p(y, this.options)), l(this.major, y.major) || l(this.minor, y.minor) || l(this.patch, y.patch);
                            }
                            comparePre(y) {
                                if (y instanceof p || (y = new p(y, this.options)), this.prerelease.length && !y.prerelease.length) return -1;
                                if (!this.prerelease.length && y.prerelease.length) return 1;
                                if (!this.prerelease.length && !y.prerelease.length) return 0;
                                let h = 0;
                                do {
                                    let g = this.prerelease[h], c = y.prerelease[h];
                                    if (t1("prerelease compare", h, g, c), g === void 0 && c === void 0) return 0;
                                    if (c === void 0) return 1;
                                    if (g === void 0) return -1;
                                    if (g === c) continue;
                                    return l(g, c);
                                }while (++h)
                            }
                            compareBuild(y) {
                                y instanceof p || (y = new p(y, this.options));
                                let h = 0;
                                do {
                                    let g = this.build[h], c = y.build[h];
                                    if (t1("prerelease compare", h, g, c), g === void 0 && c === void 0) return 0;
                                    if (c === void 0) return 1;
                                    if (g === void 0) return -1;
                                    if (g === c) continue;
                                    return l(g, c);
                                }while (++h)
                            }
                            inc(y, h) {
                                switch(y){
                                    case "premajor":
                                        this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", h);
                                        break;
                                    case "preminor":
                                        this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", h);
                                        break;
                                    case "prepatch":
                                        this.prerelease.length = 0, this.inc("patch", h), this.inc("pre", h);
                                        break;
                                    case "prerelease":
                                        this.prerelease.length === 0 && this.inc("patch", h), this.inc("pre", h);
                                        break;
                                    case "major":
                                        (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) && this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
                                        break;
                                    case "minor":
                                        (this.patch !== 0 || this.prerelease.length === 0) && this.minor++, this.patch = 0, this.prerelease = [];
                                        break;
                                    case "patch":
                                        this.prerelease.length === 0 && this.patch++, this.prerelease = [];
                                        break;
                                    case "pre":
                                        if (this.prerelease.length === 0) this.prerelease = [
                                            0
                                        ];
                                        else {
                                            let g = this.prerelease.length;
                                            for(; --g >= 0;)typeof this.prerelease[g] == "number" && (this.prerelease[g]++, g = -2);
                                            g === -1 && this.prerelease.push(0);
                                        }
                                        h && (l(this.prerelease[0], h) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = [
                                            h,
                                            0
                                        ]) : this.prerelease = [
                                            h,
                                            0
                                        ]);
                                        break;
                                    default:
                                        throw new Error(`invalid increment argument: ${y}`);
                                }
                                return this.format(), this.raw = this.version, this;
                            }
                            constructor(y, h){
                                if (h = i(h), y instanceof p) {
                                    if (y.loose === !!h.loose && y.includePrerelease === !!h.includePrerelease) return y;
                                    y = y.version;
                                } else if (typeof y != "string") throw new TypeError(`Invalid Version: ${y}`);
                                if (y.length > s) throw new TypeError(`version is longer than ${s} characters`);
                                t1("SemVer", y, h), this.options = h, this.loose = !!h.loose, this.includePrerelease = !!h.includePrerelease;
                                let g = y.trim().match(h.loose ? n[u.LOOSE] : n[u.FULL]);
                                if (!g) throw new TypeError(`Invalid Version: ${y}`);
                                if (this.raw = y, this.major = +g[1], this.minor = +g[2], this.patch = +g[3], this.major > a2 || this.major < 0) throw new TypeError("Invalid major version");
                                if (this.minor > a2 || this.minor < 0) throw new TypeError("Invalid minor version");
                                if (this.patch > a2 || this.patch < 0) throw new TypeError("Invalid patch version");
                                g[4] ? this.prerelease = g[4].split(".").map((c)=>{
                                    if (/^[0-9]+$/.test(c)) {
                                        let f2 = +c;
                                        if (f2 >= 0 && f2 < a2) return f2;
                                    }
                                    return c;
                                }) : this.prerelease = [], this.build = g[5] ? g[5].split(".") : [], this.format();
                            }
                        };
                        r.exports = p;
                    }
                }), zn = te({
                    "node_modules/semver/functions/compare.js" (e, r) {
                        ne();
                        var t1 = GD(), s = (a2, n, u)=>new t1(a2, u).compare(new t1(n, u));
                        r.exports = s;
                    }
                }), UD = te({
                    "node_modules/semver/functions/lt.js" (e, r) {
                        ne();
                        var t1 = zn(), s = (a2, n, u)=>t1(a2, n, u) < 0;
                        r.exports = s;
                    }
                }), JD = te({
                    "node_modules/semver/functions/gte.js" (e, r) {
                        ne();
                        var t1 = zn(), s = (a2, n, u)=>t1(a2, n, u) >= 0;
                        r.exports = s;
                    }
                }), zD = te({
                    "src/utils/arrayify.js" (e, r) {
                        "use strict";
                        ne(), r.exports = (t1, s)=>Object.entries(t1).map((a2)=>{
                                let [n, u] = a2;
                                return Object.assign({
                                    [s]: n
                                }, u);
                            });
                    }
                }), XD = te({
                    "node_modules/outdent/lib/index.js" (e, r) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        }), e.outdent = void 0;
                        function t1() {
                            for(var E = [], N = 0; N < arguments.length; N++)E[N] = arguments[N];
                        }
                        function s() {
                            return typeof WeakMap < "u" ? /* @__PURE__ */ new WeakMap() : a2();
                        }
                        function a2() {
                            return {
                                add: t1,
                                delete: t1,
                                get: t1,
                                set: t1,
                                has: function(E) {
                                    return false;
                                }
                            };
                        }
                        var n = Object.prototype.hasOwnProperty, u = function(E, N) {
                            return n.call(E, N);
                        };
                        function i(E, N) {
                            for(var x in N)u(N, x) && (E[x] = N[x]);
                            return E;
                        }
                        var l = /^[ \t]*(?:\r\n|\r|\n)/, p = /(?:\r\n|\r|\n)[ \t]*$/, y = /^(?:[\r\n]|$)/, h = /(?:\r\n|\r|\n)([ \t]*)(?:[^ \t\r\n]|$)/, g = /^[ \t]*[\r\n][ \t\r\n]*$/;
                        function c(E, N, x) {
                            var I = 0, P = E[0].match(h);
                            P && (I = P[1].length);
                            var $ = "(\\r\\n|\\r|\\n).{0," + I + "}", D = new RegExp($, "g");
                            N && (E = E.slice(1));
                            var T = x.newline, m = x.trimLeadingNewline, C = x.trimTrailingNewline, o = typeof T == "string", d = E.length, v = E.map(function(S, b) {
                                return S = S.replace(D, "$1"), b === 0 && m && (S = S.replace(l, "")), b === d - 1 && C && (S = S.replace(p, "")), o && (S = S.replace(/\r\n|\n|\r/g, function(B) {
                                    return T;
                                })), S;
                            });
                            return v;
                        }
                        function f2(E, N) {
                            for(var x = "", I = 0, P = E.length; I < P; I++)x += E[I], I < P - 1 && (x += N[I]);
                            return x;
                        }
                        function F(E) {
                            return u(E, "raw") && u(E, "length");
                        }
                        function _2(E) {
                            var N = s(), x = s();
                            function I($) {
                                for(var D = [], T = 1; T < arguments.length; T++)D[T - 1] = arguments[T];
                                if (F($)) {
                                    var m = $, C = (D[0] === I || D[0] === w) && g.test(m[0]) && y.test(m[1]), o = C ? x : N, d = o.get(m);
                                    if (d || (d = c(m, C, E), o.set(m, d)), D.length === 0) return d[0];
                                    var v = f2(d, C ? D.slice(1) : D);
                                    return v;
                                } else return _2(i(i({}, E), $ || {}));
                            }
                            var P = i(I, {
                                string: function($) {
                                    return c([
                                        $
                                    ], false, E)[0];
                                }
                            });
                            return P;
                        }
                        var w = _2({
                            trimLeadingNewline: true,
                            trimTrailingNewline: true
                        });
                        if (e.outdent = w, e.default = w, typeof r < "u") try {
                            r.exports = w, Object.defineProperty(w, "__esModule", {
                                value: true
                            }), w.default = w, w.outdent = w;
                        } catch  {}
                    }
                }), KD = te({
                    "src/main/core-options.js" (e, r) {
                        "use strict";
                        ne();
                        var { outdent: t1 } = XD(), s = "Config", a2 = "Editor", n = "Format", u = "Other", i = "Output", l = "Global", p = "Special", y = {
                            cursorOffset: {
                                since: "1.4.0",
                                category: p,
                                type: "int",
                                default: -1,
                                range: {
                                    start: -1,
                                    end: Number.POSITIVE_INFINITY,
                                    step: 1
                                },
                                description: t1`
      Print (to stderr) where a cursor at the given position would move to after formatting.
      This option cannot be used with --range-start and --range-end.
    `,
                                cliCategory: a2
                            },
                            endOfLine: {
                                since: "1.15.0",
                                category: l,
                                type: "choice",
                                default: [
                                    {
                                        since: "1.15.0",
                                        value: "auto"
                                    },
                                    {
                                        since: "2.0.0",
                                        value: "lf"
                                    }
                                ],
                                description: "Which end of line characters to apply.",
                                choices: [
                                    {
                                        value: "lf",
                                        description: "Line Feed only (\\n), common on Linux and macOS as well as inside git repos"
                                    },
                                    {
                                        value: "crlf",
                                        description: "Carriage Return + Line Feed characters (\\r\\n), common on Windows"
                                    },
                                    {
                                        value: "cr",
                                        description: "Carriage Return character only (\\r), used very rarely"
                                    },
                                    {
                                        value: "auto",
                                        description: t1`
          Maintain existing
          (mixed values within one file are normalised by looking at what's used after the first line)
        `
                                    }
                                ]
                            },
                            filepath: {
                                since: "1.4.0",
                                category: p,
                                type: "path",
                                description: "Specify the input filepath. This will be used to do parser inference.",
                                cliName: "stdin-filepath",
                                cliCategory: u,
                                cliDescription: "Path to the file to pretend that stdin comes from."
                            },
                            insertPragma: {
                                since: "1.8.0",
                                category: p,
                                type: "boolean",
                                default: false,
                                description: "Insert @format pragma into file's first docblock comment.",
                                cliCategory: u
                            },
                            parser: {
                                since: "0.0.10",
                                category: l,
                                type: "choice",
                                default: [
                                    {
                                        since: "0.0.10",
                                        value: "babylon"
                                    },
                                    {
                                        since: "1.13.0",
                                        value: void 0
                                    }
                                ],
                                description: "Which parser to use.",
                                exception: (h)=>typeof h == "string" || typeof h == "function",
                                choices: [
                                    {
                                        value: "flow",
                                        description: "Flow"
                                    },
                                    {
                                        value: "babel",
                                        since: "1.16.0",
                                        description: "JavaScript"
                                    },
                                    {
                                        value: "babel-flow",
                                        since: "1.16.0",
                                        description: "Flow"
                                    },
                                    {
                                        value: "babel-ts",
                                        since: "2.0.0",
                                        description: "TypeScript"
                                    },
                                    {
                                        value: "typescript",
                                        since: "1.4.0",
                                        description: "TypeScript"
                                    },
                                    {
                                        value: "acorn",
                                        since: "2.6.0",
                                        description: "JavaScript"
                                    },
                                    {
                                        value: "espree",
                                        since: "2.2.0",
                                        description: "JavaScript"
                                    },
                                    {
                                        value: "meriyah",
                                        since: "2.2.0",
                                        description: "JavaScript"
                                    },
                                    {
                                        value: "css",
                                        since: "1.7.1",
                                        description: "CSS"
                                    },
                                    {
                                        value: "less",
                                        since: "1.7.1",
                                        description: "Less"
                                    },
                                    {
                                        value: "scss",
                                        since: "1.7.1",
                                        description: "SCSS"
                                    },
                                    {
                                        value: "json",
                                        since: "1.5.0",
                                        description: "JSON"
                                    },
                                    {
                                        value: "json5",
                                        since: "1.13.0",
                                        description: "JSON5"
                                    },
                                    {
                                        value: "json-stringify",
                                        since: "1.13.0",
                                        description: "JSON.stringify"
                                    },
                                    {
                                        value: "graphql",
                                        since: "1.5.0",
                                        description: "GraphQL"
                                    },
                                    {
                                        value: "markdown",
                                        since: "1.8.0",
                                        description: "Markdown"
                                    },
                                    {
                                        value: "mdx",
                                        since: "1.15.0",
                                        description: "MDX"
                                    },
                                    {
                                        value: "vue",
                                        since: "1.10.0",
                                        description: "Vue"
                                    },
                                    {
                                        value: "yaml",
                                        since: "1.14.0",
                                        description: "YAML"
                                    },
                                    {
                                        value: "glimmer",
                                        since: "2.3.0",
                                        description: "Ember / Handlebars"
                                    },
                                    {
                                        value: "html",
                                        since: "1.15.0",
                                        description: "HTML"
                                    },
                                    {
                                        value: "angular",
                                        since: "1.15.0",
                                        description: "Angular"
                                    },
                                    {
                                        value: "lwc",
                                        since: "1.17.0",
                                        description: "Lightning Web Components"
                                    }
                                ]
                            },
                            plugins: {
                                since: "1.10.0",
                                type: "path",
                                array: true,
                                default: [
                                    {
                                        value: []
                                    }
                                ],
                                category: l,
                                description: "Add a plugin. Multiple plugins can be passed as separate `--plugin`s.",
                                exception: (h)=>typeof h == "string" || typeof h == "object",
                                cliName: "plugin",
                                cliCategory: s
                            },
                            pluginSearchDirs: {
                                since: "1.13.0",
                                type: "path",
                                array: true,
                                default: [
                                    {
                                        value: []
                                    }
                                ],
                                category: l,
                                description: t1`
      Custom directory that contains prettier plugins in node_modules subdirectory.
      Overrides default behavior when plugins are searched relatively to the location of Prettier.
      Multiple values are accepted.
    `,
                                exception: (h)=>typeof h == "string" || typeof h == "object",
                                cliName: "plugin-search-dir",
                                cliCategory: s
                            },
                            printWidth: {
                                since: "0.0.0",
                                category: l,
                                type: "int",
                                default: 80,
                                description: "The line length where Prettier will try wrap.",
                                range: {
                                    start: 0,
                                    end: Number.POSITIVE_INFINITY,
                                    step: 1
                                }
                            },
                            rangeEnd: {
                                since: "1.4.0",
                                category: p,
                                type: "int",
                                default: Number.POSITIVE_INFINITY,
                                range: {
                                    start: 0,
                                    end: Number.POSITIVE_INFINITY,
                                    step: 1
                                },
                                description: t1`
      Format code ending at a given character offset (exclusive).
      The range will extend forwards to the end of the selected statement.
      This option cannot be used with --cursor-offset.
    `,
                                cliCategory: a2
                            },
                            rangeStart: {
                                since: "1.4.0",
                                category: p,
                                type: "int",
                                default: 0,
                                range: {
                                    start: 0,
                                    end: Number.POSITIVE_INFINITY,
                                    step: 1
                                },
                                description: t1`
      Format code starting at a given character offset.
      The range will extend backwards to the start of the first line containing the selected statement.
      This option cannot be used with --cursor-offset.
    `,
                                cliCategory: a2
                            },
                            requirePragma: {
                                since: "1.7.0",
                                category: p,
                                type: "boolean",
                                default: false,
                                description: t1`
      Require either '@prettier' or '@format' to be present in the file's first docblock comment
      in order for it to be formatted.
    `,
                                cliCategory: u
                            },
                            tabWidth: {
                                type: "int",
                                category: l,
                                default: 2,
                                description: "Number of spaces per indentation level.",
                                range: {
                                    start: 0,
                                    end: Number.POSITIVE_INFINITY,
                                    step: 1
                                }
                            },
                            useTabs: {
                                since: "1.0.0",
                                category: l,
                                type: "boolean",
                                default: false,
                                description: "Indent with tabs instead of spaces."
                            },
                            embeddedLanguageFormatting: {
                                since: "2.1.0",
                                category: l,
                                type: "choice",
                                default: [
                                    {
                                        since: "2.1.0",
                                        value: "auto"
                                    }
                                ],
                                description: "Control how Prettier formats quoted code embedded in the file.",
                                choices: [
                                    {
                                        value: "auto",
                                        description: "Format embedded code if Prettier can automatically identify it."
                                    },
                                    {
                                        value: "off",
                                        description: "Never automatically format embedded code."
                                    }
                                ]
                            }
                        };
                        r.exports = {
                            CATEGORY_CONFIG: s,
                            CATEGORY_EDITOR: a2,
                            CATEGORY_FORMAT: n,
                            CATEGORY_OTHER: u,
                            CATEGORY_OUTPUT: i,
                            CATEGORY_GLOBAL: l,
                            CATEGORY_SPECIAL: p,
                            options: y
                        };
                    }
                }), Xn = te({
                    "src/main/support.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = {
                            compare: zn(),
                            lt: UD(),
                            gte: JD()
                        }, s = zD(), a2 = Ia().version, n = KD().options;
                        function u() {
                            let { plugins: l = [], showUnreleased: p = false, showDeprecated: y = false, showInternal: h = false } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, g = a2.split("-", 1)[0], c = l.flatMap((E)=>E.languages || []).filter(F), f2 = s(Object.assign({}, ...l.map((E)=>{
                                let { options: N } = E;
                                return N;
                            }), n), "name").filter((E)=>F(E) && _2(E)).sort((E, N)=>E.name === N.name ? 0 : E.name < N.name ? -1 : 1).map(w).map((E)=>{
                                E = Object.assign({}, E), Array.isArray(E.default) && (E.default = E.default.length === 1 ? E.default[0].value : E.default.filter(F).sort((x, I)=>t1.compare(I.since, x.since))[0].value), Array.isArray(E.choices) && (E.choices = E.choices.filter((x)=>F(x) && _2(x)), E.name === "parser" && i(E, c, l));
                                let N = Object.fromEntries(l.filter((x)=>x.defaultOptions && x.defaultOptions[E.name] !== void 0).map((x)=>[
                                        x.name,
                                        x.defaultOptions[E.name]
                                    ]));
                                return Object.assign(Object.assign({}, E), {}, {
                                    pluginDefaults: N
                                });
                            });
                            return {
                                languages: c,
                                options: f2
                            };
                            function F(E) {
                                return p || !("since" in E) || E.since && t1.gte(g, E.since);
                            }
                            function _2(E) {
                                return y || !("deprecated" in E) || E.deprecated && t1.lt(g, E.deprecated);
                            }
                            function w(E) {
                                if (h) return E;
                                let { cliName: N, cliCategory: x, cliDescription: I } = E;
                                return Hn(E, hD);
                            }
                        }
                        function i(l, p, y) {
                            let h = new Set(l.choices.map((g)=>g.value));
                            for (let g of p)if (g.parsers) {
                                for (let c of g.parsers)if (!h.has(c)) {
                                    h.add(c);
                                    let f2 = y.find((_2)=>_2.parsers && _2.parsers[c]), F = g.name;
                                    f2 && f2.name && (F += ` (plugin: ${f2.name})`), l.choices.push({
                                        value: c,
                                        description: F
                                    });
                                }
                            }
                        }
                        r.exports = {
                            getSupportInfo: u
                        };
                    }
                }), Kn = te({
                    "src/utils/is-non-empty-array.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s) {
                            return Array.isArray(s) && s.length > 0;
                        }
                        r.exports = t1;
                    }
                }), Pr = te({
                    "src/utils/text/skip.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(i) {
                            return (l, p, y)=>{
                                let h = y && y.backwards;
                                if (p === false) return false;
                                let { length: g } = l, c = p;
                                for(; c >= 0 && c < g;){
                                    let f2 = l.charAt(c);
                                    if (i instanceof RegExp) {
                                        if (!i.test(f2)) return c;
                                    } else if (!i.includes(f2)) return c;
                                    h ? c-- : c++;
                                }
                                return c === -1 || c === g ? c : false;
                            };
                        }
                        var s = t1(/\s/), a2 = t1(" 	"), n = t1(",; 	"), u = t1(/[^\n\r]/);
                        r.exports = {
                            skipWhitespace: s,
                            skipSpaces: a2,
                            skipToLineEnd: n,
                            skipEverythingButNewLine: u
                        };
                    }
                }), Ra = te({
                    "src/utils/text/skip-inline-comment.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s, a2) {
                            if (a2 === false) return false;
                            if (s.charAt(a2) === "/" && s.charAt(a2 + 1) === "*") {
                                for(let n = a2 + 2; n < s.length; ++n)if (s.charAt(n) === "*" && s.charAt(n + 1) === "/") return n + 2;
                            }
                            return a2;
                        }
                        r.exports = t1;
                    }
                }), $a = te({
                    "src/utils/text/skip-trailing-comment.js" (e, r) {
                        "use strict";
                        ne();
                        var { skipEverythingButNewLine: t1 } = Pr();
                        function s(a2, n) {
                            return n === false ? false : a2.charAt(n) === "/" && a2.charAt(n + 1) === "/" ? t1(a2, n) : n;
                        }
                        r.exports = s;
                    }
                }), Va = te({
                    "src/utils/text/skip-newline.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s, a2, n) {
                            let u = n && n.backwards;
                            if (a2 === false) return false;
                            let i = s.charAt(a2);
                            if (u) {
                                if (s.charAt(a2 - 1) === "\r" && i === `
`) return a2 - 2;
                                if (i === `
` || i === "\r" || i === "\u2028" || i === "\u2029") return a2 - 1;
                            } else {
                                if (i === "\r" && s.charAt(a2 + 1) === `
`) return a2 + 2;
                                if (i === `
` || i === "\r" || i === "\u2028" || i === "\u2029") return a2 + 1;
                            }
                            return a2;
                        }
                        r.exports = t1;
                    }
                }), YD = te({
                    "src/utils/text/get-next-non-space-non-comment-character-index-with-start-index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Ra(), s = Va(), a2 = $a(), { skipSpaces: n } = Pr();
                        function u(i, l) {
                            let p = null, y = l;
                            for(; y !== p;)p = y, y = n(i, y), y = t1(i, y), y = a2(i, y), y = s(i, y);
                            return y;
                        }
                        r.exports = u;
                    }
                }), Ue = te({
                    "src/common/util.js" (e, r) {
                        "use strict";
                        ne();
                        var { default: t1 } = ($D(), ft(ja)), s = lt(), { getSupportInfo: a2 } = Xn(), n = Kn(), u = Oa(), { skipWhitespace: i, skipSpaces: l, skipToLineEnd: p, skipEverythingButNewLine: y } = Pr(), h = Ra(), g = $a(), c = Va(), f2 = YD(), F = (V)=>V[V.length - 2];
                        function _2(V) {
                            return (j, Y, ie)=>{
                                let ee = ie && ie.backwards;
                                if (Y === false) return false;
                                let { length: ce } = j, W = Y;
                                for(; W >= 0 && W < ce;){
                                    let K = j.charAt(W);
                                    if (V instanceof RegExp) {
                                        if (!V.test(K)) return W;
                                    } else if (!V.includes(K)) return W;
                                    ee ? W-- : W++;
                                }
                                return W === -1 || W === ce ? W : false;
                            };
                        }
                        function w(V, j) {
                            let Y = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, ie = l(V, Y.backwards ? j - 1 : j, Y), ee = c(V, ie, Y);
                            return ie !== ee;
                        }
                        function E(V, j, Y) {
                            for(let ie = j; ie < Y; ++ie)if (V.charAt(ie) === `
`) return true;
                            return false;
                        }
                        function N(V, j, Y) {
                            let ie = Y(j) - 1;
                            ie = l(V, ie, {
                                backwards: true
                            }), ie = c(V, ie, {
                                backwards: true
                            }), ie = l(V, ie, {
                                backwards: true
                            });
                            let ee = c(V, ie, {
                                backwards: true
                            });
                            return ie !== ee;
                        }
                        function x(V, j) {
                            let Y = null, ie = j;
                            for(; ie !== Y;)Y = ie, ie = p(V, ie), ie = h(V, ie), ie = l(V, ie);
                            return ie = g(V, ie), ie = c(V, ie), ie !== false && w(V, ie);
                        }
                        function I(V, j, Y) {
                            return x(V, Y(j));
                        }
                        function P(V, j, Y) {
                            return f2(V, Y(j));
                        }
                        function $(V, j, Y) {
                            return V.charAt(P(V, j, Y));
                        }
                        function D(V, j) {
                            let Y = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
                            return l(V, Y.backwards ? j - 1 : j, Y) !== j;
                        }
                        function T(V, j) {
                            let Y = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0, ie = 0;
                            for(let ee = Y; ee < V.length; ++ee)V[ee] === "	" ? ie = ie + j - ie % j : ie++;
                            return ie;
                        }
                        function m(V, j) {
                            let Y = V.lastIndexOf(`
`);
                            return Y === -1 ? 0 : T(V.slice(Y + 1).match(/^[\t ]*/)[0], j);
                        }
                        function C(V, j) {
                            let Y = {
                                quote: '"',
                                regex: /"/g,
                                escaped: "&quot;"
                            }, ie = {
                                quote: "'",
                                regex: /'/g,
                                escaped: "&apos;"
                            }, ee = j === "'" ? ie : Y, ce = ee === ie ? Y : ie, W = ee;
                            if (V.includes(ee.quote) || V.includes(ce.quote)) {
                                let K = (V.match(ee.regex) || []).length, de = (V.match(ce.regex) || []).length;
                                W = K > de ? ce : ee;
                            }
                            return W;
                        }
                        function o(V, j) {
                            let Y = V.slice(1, -1), ie = j.parser === "json" || j.parser === "json5" && j.quoteProps === "preserve" && !j.singleQuote ? '"' : j.__isInHtmlAttribute ? "'" : C(Y, j.singleQuote ? "'" : '"').quote;
                            return d(Y, ie, !(j.parser === "css" || j.parser === "less" || j.parser === "scss" || j.__embeddedInHtml));
                        }
                        function d(V, j, Y) {
                            let ie = j === '"' ? "'" : '"', ee = RegExp("\\\\(.)|([\"'])", "gs"), ce = V.replace(ee, (W, K, de)=>K === ie ? K : de === j ? "\\" + de : de || (Y && /^[^\n\r"'0-7\\bfnrt-vx\u2028\u2029]$/.test(K) ? K : "\\" + K));
                            return j + ce + j;
                        }
                        function v(V) {
                            return V.toLowerCase().replace(/^([+-]?[\d.]+e)(?:\+|(-))?0*(\d)/, "$1$2$3").replace(/^([+-]?[\d.]+)e[+-]?0+$/, "$1").replace(/^([+-])?\./, "$10.").replace(/(\.\d+?)0+(?=e|$)/, "$1").replace(/\.(?=e|$)/, "");
                        }
                        function S(V, j) {
                            let Y = V.match(new RegExp(`(${t1(j)})+`, "g"));
                            return Y === null ? 0 : Y.reduce((ie, ee)=>Math.max(ie, ee.length / j.length), 0);
                        }
                        function b(V, j) {
                            let Y = V.match(new RegExp(`(${t1(j)})+`, "g"));
                            if (Y === null) return 0;
                            let ie = /* @__PURE__ */ new Map(), ee = 0;
                            for (let ce of Y){
                                let W = ce.length / j.length;
                                ie.set(W, true), W > ee && (ee = W);
                            }
                            for(let ce = 1; ce < ee; ce++)if (!ie.get(ce)) return ce;
                            return ee + 1;
                        }
                        function B(V, j) {
                            (V.comments || (V.comments = [])).push(j), j.printed = false, j.nodeDescription = Q(V);
                        }
                        function k(V, j) {
                            j.leading = true, j.trailing = false, B(V, j);
                        }
                        function M(V, j, Y) {
                            j.leading = false, j.trailing = false, Y && (j.marker = Y), B(V, j);
                        }
                        function R(V, j) {
                            j.leading = false, j.trailing = true, B(V, j);
                        }
                        function q(V, j) {
                            let { languages: Y } = a2({
                                plugins: j.plugins
                            }), ie = Y.find((ee)=>{
                                let { name: ce } = ee;
                                return ce.toLowerCase() === V;
                            }) || Y.find((ee)=>{
                                let { aliases: ce } = ee;
                                return Array.isArray(ce) && ce.includes(V);
                            }) || Y.find((ee)=>{
                                let { extensions: ce } = ee;
                                return Array.isArray(ce) && ce.includes(`.${V}`);
                            });
                            return ie && ie.parsers[0];
                        }
                        function J(V) {
                            return V && V.type === "front-matter";
                        }
                        function L(V) {
                            let j = /* @__PURE__ */ new WeakMap();
                            return function(Y) {
                                return j.has(Y) || j.set(Y, Symbol(V)), j.get(Y);
                            };
                        }
                        function Q(V) {
                            let j = V.type || V.kind || "(unknown type)", Y = String(V.name || V.id && (typeof V.id == "object" ? V.id.name : V.id) || V.key && (typeof V.key == "object" ? V.key.name : V.key) || V.value && (typeof V.value == "object" ? "" : String(V.value)) || V.operator || "");
                            return Y.length > 20 && (Y = Y.slice(0, 19) + "\u2026"), j + (Y ? " " + Y : "");
                        }
                        r.exports = {
                            inferParserByLanguage: q,
                            getStringWidth: u,
                            getMaxContinuousCount: S,
                            getMinNotPresentContinuousCount: b,
                            getPenultimate: F,
                            getLast: s,
                            getNextNonSpaceNonCommentCharacterIndexWithStartIndex: f2,
                            getNextNonSpaceNonCommentCharacterIndex: P,
                            getNextNonSpaceNonCommentCharacter: $,
                            skip: _2,
                            skipWhitespace: i,
                            skipSpaces: l,
                            skipToLineEnd: p,
                            skipEverythingButNewLine: y,
                            skipInlineComment: h,
                            skipTrailingComment: g,
                            skipNewline: c,
                            isNextLineEmptyAfterIndex: x,
                            isNextLineEmpty: I,
                            isPreviousLineEmpty: N,
                            hasNewline: w,
                            hasNewlineInRange: E,
                            hasSpaces: D,
                            getAlignmentSize: T,
                            getIndentSize: m,
                            getPreferredQuote: C,
                            printString: o,
                            printNumber: v,
                            makeString: d,
                            addLeadingComment: k,
                            addDanglingComment: M,
                            addTrailingComment: R,
                            isFrontMatterNode: J,
                            isNonEmptyArray: n,
                            createGroupIdMapper: L
                        };
                    }
                }), Wa = {};
                Kt(Wa, {
                    basename: ()=>za,
                    default: ()=>Ka,
                    delimiter: ()=>Mn,
                    dirname: ()=>Ja,
                    extname: ()=>Xa,
                    isAbsolute: ()=>Qn,
                    join: ()=>Ga,
                    normalize: ()=>Yn,
                    relative: ()=>Ua,
                    resolve: ()=>wr,
                    sep: ()=>qn
                });
                function Ha(e, r) {
                    for(var t1 = 0, s = e.length - 1; s >= 0; s--){
                        var a2 = e[s];
                        a2 === "." ? e.splice(s, 1) : a2 === ".." ? (e.splice(s, 1), t1++) : t1 && (e.splice(s, 1), t1--);
                    }
                    if (r) for(; t1--; t1)e.unshift("..");
                    return e;
                }
                function wr() {
                    for(var e = "", r = false, t1 = arguments.length - 1; t1 >= -1 && !r; t1--){
                        var s = t1 >= 0 ? arguments[t1] : "/";
                        if (typeof s != "string") throw new TypeError("Arguments to path.resolve must be strings");
                        if (!s) continue;
                        e = s + "/" + e, r = s.charAt(0) === "/";
                    }
                    return e = Ha(Zn(e.split("/"), function(a2) {
                        return !!a2;
                    }), !r).join("/"), (r ? "/" : "") + e || ".";
                }
                function Yn(e) {
                    var r = Qn(e), t1 = Ya(e, -1) === "/";
                    return e = Ha(Zn(e.split("/"), function(s) {
                        return !!s;
                    }), !r).join("/"), !e && !r && (e = "."), e && t1 && (e += "/"), (r ? "/" : "") + e;
                }
                function Qn(e) {
                    return e.charAt(0) === "/";
                }
                function Ga() {
                    var e = Array.prototype.slice.call(arguments, 0);
                    return Yn(Zn(e, function(r, t1) {
                        if (typeof r != "string") throw new TypeError("Arguments to path.join must be strings");
                        return r;
                    }).join("/"));
                }
                function Ua(e, r) {
                    e = wr(e).substr(1), r = wr(r).substr(1);
                    function t1(p) {
                        for(var y = 0; y < p.length && p[y] === ""; y++);
                        for(var h = p.length - 1; h >= 0 && p[h] === ""; h--);
                        return y > h ? [] : p.slice(y, h - y + 1);
                    }
                    for(var s = t1(e.split("/")), a2 = t1(r.split("/")), n = Math.min(s.length, a2.length), u = n, i = 0; i < n; i++)if (s[i] !== a2[i]) {
                        u = i;
                        break;
                    }
                    for(var l = [], i = u; i < s.length; i++)l.push("..");
                    return l = l.concat(a2.slice(u)), l.join("/");
                }
                function Ja(e) {
                    var r = Ir(e), t1 = r[0], s = r[1];
                    return !t1 && !s ? "." : (s && (s = s.substr(0, s.length - 1)), t1 + s);
                }
                function za(e, r) {
                    var t1 = Ir(e)[2];
                    return r && t1.substr(-1 * r.length) === r && (t1 = t1.substr(0, t1.length - r.length)), t1;
                }
                function Xa(e) {
                    return Ir(e)[3];
                }
                function Zn(e, r) {
                    if (e.filter) return e.filter(r);
                    for(var t1 = [], s = 0; s < e.length; s++)r(e[s], s, e) && t1.push(e[s]);
                    return t1;
                }
                var Na, Ir, qn, Mn, Ka, Ya, QD = ht({
                    "node-modules-polyfills:path" () {
                        ne(), Na = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/, Ir = function(e) {
                            return Na.exec(e).slice(1);
                        }, qn = "/", Mn = ":", Ka = {
                            extname: Xa,
                            basename: za,
                            dirname: Ja,
                            sep: qn,
                            delimiter: Mn,
                            relative: Ua,
                            join: Ga,
                            isAbsolute: Qn,
                            normalize: Yn,
                            resolve: wr
                        }, Ya =  true ? function(e, r, t1) {
                            return e.substr(r, t1);
                        } : 0;
                    }
                }), ZD = te({
                    "node-modules-polyfills-commonjs:path" (e, r) {
                        ne();
                        var t1 = (QD(), ft(Wa));
                        if (t1 && t1.default) {
                            r.exports = t1.default;
                            for(let s in t1)r.exports[s] = t1[s];
                        } else t1 && (r.exports = t1);
                    }
                }), Qt = te({
                    "src/common/errors.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = class extends Error {
                        }, s = class extends Error {
                        }, a2 = class extends Error {
                        }, n = class extends Error {
                        };
                        r.exports = {
                            ConfigError: t1,
                            DebugError: s,
                            UndefinedParserError: a2,
                            ArgExpansionBailout: n
                        };
                    }
                }), vt = {};
                Kt(vt, {
                    __assign: ()=>Nr,
                    __asyncDelegator: ()=>fm,
                    __asyncGenerator: ()=>pm,
                    __asyncValues: ()=>Dm,
                    __await: ()=>Xt,
                    __awaiter: ()=>sm,
                    __classPrivateFieldGet: ()=>ym,
                    __classPrivateFieldSet: ()=>hm,
                    __createBinding: ()=>am,
                    __decorate: ()=>rm,
                    __exportStar: ()=>om,
                    __extends: ()=>em,
                    __generator: ()=>im,
                    __importDefault: ()=>gm,
                    __importStar: ()=>dm,
                    __makeTemplateObject: ()=>mm,
                    __metadata: ()=>um,
                    __param: ()=>nm,
                    __read: ()=>Qa,
                    __rest: ()=>tm,
                    __spread: ()=>lm,
                    __spreadArrays: ()=>cm,
                    __values: ()=>Rn
                });
                function em(e, r) {
                    Br(e, r);
                    function t1() {
                        this.constructor = e;
                    }
                    e.prototype = r === null ? Object.create(r) : (t1.prototype = r.prototype, new t1());
                }
                function tm(e, r) {
                    var t1 = {};
                    for(var s in e)Object.prototype.hasOwnProperty.call(e, s) && r.indexOf(s) < 0 && (t1[s] = e[s]);
                    if (e != null && typeof Object.getOwnPropertySymbols == "function") for(var a2 = 0, s = Object.getOwnPropertySymbols(e); a2 < s.length; a2++)r.indexOf(s[a2]) < 0 && Object.prototype.propertyIsEnumerable.call(e, s[a2]) && (t1[s[a2]] = e[s[a2]]);
                    return t1;
                }
                function rm(e, r, t1, s) {
                    var a2 = arguments.length, n = a2 < 3 ? r : s === null ? s = Object.getOwnPropertyDescriptor(r, t1) : s, u;
                    if (typeof Reflect == "object" && typeof Reflect.decorate == "function") n = Reflect.decorate(e, r, t1, s);
                    else for(var i = e.length - 1; i >= 0; i--)(u = e[i]) && (n = (a2 < 3 ? u(n) : a2 > 3 ? u(r, t1, n) : u(r, t1)) || n);
                    return a2 > 3 && n && Object.defineProperty(r, t1, n), n;
                }
                function nm(e, r) {
                    return function(t1, s) {
                        r(t1, s, e);
                    };
                }
                function um(e, r) {
                    if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, r);
                }
                function sm(e, r, t1, s) {
                    function a2(n) {
                        return n instanceof t1 ? n : new t1(function(u) {
                            u(n);
                        });
                    }
                    return new (t1 || (t1 = Promise))(function(n, u) {
                        function i(y) {
                            try {
                                p(s.next(y));
                            } catch (h) {
                                u(h);
                            }
                        }
                        function l(y) {
                            try {
                                p(s.throw(y));
                            } catch (h) {
                                u(h);
                            }
                        }
                        function p(y) {
                            y.done ? n(y.value) : a2(y.value).then(i, l);
                        }
                        p((s = s.apply(e, r || [])).next());
                    });
                }
                function im(e, r) {
                    var t1 = {
                        label: 0,
                        sent: function() {
                            if (n[0] & 1) throw n[1];
                            return n[1];
                        },
                        trys: [],
                        ops: []
                    }, s, a2, n, u;
                    return u = {
                        next: i(0),
                        throw: i(1),
                        return: i(2)
                    }, typeof Symbol == "function" && (u[Symbol.iterator] = function() {
                        return this;
                    }), u;
                    function i(p) {
                        return function(y) {
                            return l([
                                p,
                                y
                            ]);
                        };
                    }
                    function l(p) {
                        if (s) throw new TypeError("Generator is already executing.");
                        for(; t1;)try {
                            if (s = 1, a2 && (n = p[0] & 2 ? a2.return : p[0] ? a2.throw || ((n = a2.return) && n.call(a2), 0) : a2.next) && !(n = n.call(a2, p[1])).done) return n;
                            switch(a2 = 0, n && (p = [
                                p[0] & 2,
                                n.value
                            ]), p[0]){
                                case 0:
                                case 1:
                                    n = p;
                                    break;
                                case 4:
                                    return t1.label++, {
                                        value: p[1],
                                        done: false
                                    };
                                case 5:
                                    t1.label++, a2 = p[1], p = [
                                        0
                                    ];
                                    continue;
                                case 7:
                                    p = t1.ops.pop(), t1.trys.pop();
                                    continue;
                                default:
                                    if (n = t1.trys, !(n = n.length > 0 && n[n.length - 1]) && (p[0] === 6 || p[0] === 2)) {
                                        t1 = 0;
                                        continue;
                                    }
                                    if (p[0] === 3 && (!n || p[1] > n[0] && p[1] < n[3])) {
                                        t1.label = p[1];
                                        break;
                                    }
                                    if (p[0] === 6 && t1.label < n[1]) {
                                        t1.label = n[1], n = p;
                                        break;
                                    }
                                    if (n && t1.label < n[2]) {
                                        t1.label = n[2], t1.ops.push(p);
                                        break;
                                    }
                                    n[2] && t1.ops.pop(), t1.trys.pop();
                                    continue;
                            }
                            p = r.call(e, t1);
                        } catch (y) {
                            p = [
                                6,
                                y
                            ], a2 = 0;
                        } finally{
                            s = n = 0;
                        }
                        if (p[0] & 5) throw p[1];
                        return {
                            value: p[0] ? p[1] : void 0,
                            done: true
                        };
                    }
                }
                function am(e, r, t1, s) {
                    s === void 0 && (s = t1), e[s] = r[t1];
                }
                function om(e, r) {
                    for(var t1 in e)t1 !== "default" && !r.hasOwnProperty(t1) && (r[t1] = e[t1]);
                }
                function Rn(e) {
                    var r = typeof Symbol == "function" && Symbol.iterator, t1 = r && e[r], s = 0;
                    if (t1) return t1.call(e);
                    if (e && typeof e.length == "number") return {
                        next: function() {
                            return e && s >= e.length && (e = void 0), {
                                value: e && e[s++],
                                done: !e
                            };
                        }
                    };
                    throw new TypeError(r ? "Object is not iterable." : "Symbol.iterator is not defined.");
                }
                function Qa(e, r) {
                    var t1 = typeof Symbol == "function" && e[Symbol.iterator];
                    if (!t1) return e;
                    var s = t1.call(e), a2, n = [], u;
                    try {
                        for(; (r === void 0 || r-- > 0) && !(a2 = s.next()).done;)n.push(a2.value);
                    } catch (i) {
                        u = {
                            error: i
                        };
                    } finally{
                        try {
                            a2 && !a2.done && (t1 = s.return) && t1.call(s);
                        } finally{
                            if (u) throw u.error;
                        }
                    }
                    return n;
                }
                function lm() {
                    for(var e = [], r = 0; r < arguments.length; r++)e = e.concat(Qa(arguments[r]));
                    return e;
                }
                function cm() {
                    for(var e = 0, r = 0, t1 = arguments.length; r < t1; r++)e += arguments[r].length;
                    for(var s = Array(e), a2 = 0, r = 0; r < t1; r++)for(var n = arguments[r], u = 0, i = n.length; u < i; u++, a2++)s[a2] = n[u];
                    return s;
                }
                function Xt(e) {
                    return this instanceof Xt ? (this.v = e, this) : new Xt(e);
                }
                function pm(e, r, t1) {
                    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
                    var s = t1.apply(e, r || []), a2, n = [];
                    return a2 = {}, u("next"), u("throw"), u("return"), a2[Symbol.asyncIterator] = function() {
                        return this;
                    }, a2;
                    function u(g) {
                        s[g] && (a2[g] = function(c) {
                            return new Promise(function(f2, F) {
                                n.push([
                                    g,
                                    c,
                                    f2,
                                    F
                                ]) > 1 || i(g, c);
                            });
                        });
                    }
                    function i(g, c) {
                        try {
                            l(s[g](c));
                        } catch (f2) {
                            h(n[0][3], f2);
                        }
                    }
                    function l(g) {
                        g.value instanceof Xt ? Promise.resolve(g.value.v).then(p, y) : h(n[0][2], g);
                    }
                    function p(g) {
                        i("next", g);
                    }
                    function y(g) {
                        i("throw", g);
                    }
                    function h(g, c) {
                        g(c), n.shift(), n.length && i(n[0][0], n[0][1]);
                    }
                }
                function fm(e) {
                    var r, t1;
                    return r = {}, s("next"), s("throw", function(a2) {
                        throw a2;
                    }), s("return"), r[Symbol.iterator] = function() {
                        return this;
                    }, r;
                    function s(a2, n) {
                        r[a2] = e[a2] ? function(u) {
                            return (t1 = !t1) ? {
                                value: Xt(e[a2](u)),
                                done: a2 === "return"
                            } : n ? n(u) : u;
                        } : n;
                    }
                }
                function Dm(e) {
                    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
                    var r = e[Symbol.asyncIterator], t1;
                    return r ? r.call(e) : (e = typeof Rn == "function" ? Rn(e) : e[Symbol.iterator](), t1 = {}, s("next"), s("throw"), s("return"), t1[Symbol.asyncIterator] = function() {
                        return this;
                    }, t1);
                    function s(n) {
                        t1[n] = e[n] && function(u) {
                            return new Promise(function(i, l) {
                                u = e[n](u), a2(i, l, u.done, u.value);
                            });
                        };
                    }
                    function a2(n, u, i, l) {
                        Promise.resolve(l).then(function(p) {
                            n({
                                value: p,
                                done: i
                            });
                        }, u);
                    }
                }
                function mm(e, r) {
                    return Object.defineProperty ? Object.defineProperty(e, "raw", {
                        value: r
                    }) : e.raw = r, e;
                }
                function dm(e) {
                    if (e && e.__esModule) return e;
                    var r = {};
                    if (e != null) for(var t1 in e)Object.hasOwnProperty.call(e, t1) && (r[t1] = e[t1]);
                    return r.default = e, r;
                }
                function gm(e) {
                    return e && e.__esModule ? e : {
                        default: e
                    };
                }
                function ym(e, r) {
                    if (!r.has(e)) throw new TypeError("attempted to get private field on non-instance");
                    return r.get(e);
                }
                function hm(e, r, t1) {
                    if (!r.has(e)) throw new TypeError("attempted to set private field on non-instance");
                    return r.set(e, t1), t1;
                }
                var Br, Nr, Et = ht({
                    "node_modules/tslib/tslib.es6.js" () {
                        ne(), Br = function(e, r) {
                            return Br = Object.setPrototypeOf || ({
                                __proto__: []
                            }) instanceof Array && function(t1, s) {
                                t1.__proto__ = s;
                            } || function(t1, s) {
                                for(var a2 in s)s.hasOwnProperty(a2) && (t1[a2] = s[a2]);
                            }, Br(e, r);
                        }, Nr = function() {
                            return Nr = Object.assign || function(r) {
                                for(var t1, s = 1, a2 = arguments.length; s < a2; s++){
                                    t1 = arguments[s];
                                    for(var n in t1)Object.prototype.hasOwnProperty.call(t1, n) && (r[n] = t1[n]);
                                }
                                return r;
                            }, Nr.apply(this, arguments);
                        };
                    }
                }), Za = te({
                    "node_modules/vnopts/lib/descriptors/api.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        }), e.apiDescriptor = {
                            key: (r)=>/^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(r) ? r : JSON.stringify(r),
                            value (r) {
                                if (r === null || typeof r != "object") return JSON.stringify(r);
                                if (Array.isArray(r)) return `[${r.map((s)=>e.apiDescriptor.value(s)).join(", ")}]`;
                                let t1 = Object.keys(r);
                                return t1.length === 0 ? "{}" : `{ ${t1.map((s)=>`${e.apiDescriptor.key(s)}: ${e.apiDescriptor.value(r[s])}`).join(", ")} }`;
                            },
                            pair: (r)=>{
                                let { key: t1, value: s } = r;
                                return e.apiDescriptor.value({
                                    [t1]: s
                                });
                            }
                        };
                    }
                }), vm = te({
                    "node_modules/vnopts/lib/descriptors/index.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = (Et(), ft(vt));
                        r.__exportStar(Za(), e);
                    }
                }), kr = te({
                    "scripts/build/shims/chalk.cjs" (e, r) {
                        "use strict";
                        ne();
                        var t1 = (s)=>s;
                        t1.grey = t1, t1.red = t1, t1.bold = t1, t1.yellow = t1, t1.blue = t1, t1.default = t1, r.exports = t1;
                    }
                }), eo = te({
                    "node_modules/vnopts/lib/handlers/deprecated/common.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = kr();
                        e.commonDeprecatedHandler = (t1, s, a2)=>{
                            let { descriptor: n } = a2, u = [
                                `${r.default.yellow(typeof t1 == "string" ? n.key(t1) : n.pair(t1))} is deprecated`
                            ];
                            return s && u.push(`we now treat it as ${r.default.blue(typeof s == "string" ? n.key(s) : n.pair(s))}`), u.join("; ") + ".";
                        };
                    }
                }), Cm = te({
                    "node_modules/vnopts/lib/handlers/deprecated/index.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = (Et(), ft(vt));
                        r.__exportStar(eo(), e);
                    }
                }), Em = te({
                    "node_modules/vnopts/lib/handlers/invalid/common.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = kr();
                        e.commonInvalidHandler = (t1, s, a2)=>[
                                `Invalid ${r.default.red(a2.descriptor.key(t1))} value.`,
                                `Expected ${r.default.blue(a2.schemas[t1].expected(a2))},`,
                                `but received ${r.default.red(a2.descriptor.value(s))}.`
                            ].join(" ");
                    }
                }), to = te({
                    "node_modules/vnopts/lib/handlers/invalid/index.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = (Et(), ft(vt));
                        r.__exportStar(Em(), e);
                    }
                }), Fm = te({
                    "node_modules/vnopts/node_modules/leven/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = [], s = [];
                        r.exports = function(a2, n) {
                            if (a2 === n) return 0;
                            var u = a2;
                            a2.length > n.length && (a2 = n, n = u);
                            var i = a2.length, l = n.length;
                            if (i === 0) return l;
                            if (l === 0) return i;
                            for(; i > 0 && a2.charCodeAt(~-i) === n.charCodeAt(~-l);)i--, l--;
                            if (i === 0) return l;
                            for(var p = 0; p < i && a2.charCodeAt(p) === n.charCodeAt(p);)p++;
                            if (i -= p, l -= p, i === 0) return l;
                            for(var y, h, g, c, f2 = 0, F = 0; f2 < i;)s[p + f2] = a2.charCodeAt(p + f2), t1[f2] = ++f2;
                            for(; F < l;)for(y = n.charCodeAt(p + F), g = F++, h = F, f2 = 0; f2 < i; f2++)c = y === s[p + f2] ? g : g + 1, g = t1[f2], h = t1[f2] = g > h ? c > h ? h + 1 : c : c > g ? g + 1 : c;
                            return h;
                        };
                    }
                }), ro = te({
                    "node_modules/vnopts/lib/handlers/unknown/leven.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = kr(), t1 = Fm();
                        e.levenUnknownHandler = (s, a2, n)=>{
                            let { descriptor: u, logger: i, schemas: l } = n, p = [
                                `Ignored unknown option ${r.default.yellow(u.pair({
                                    key: s,
                                    value: a2
                                }))}.`
                            ], y = Object.keys(l).sort().find((h)=>t1(s, h) < 3);
                            y && p.push(`Did you mean ${r.default.blue(u.key(y))}?`), i.warn(p.join(" "));
                        };
                    }
                }), Am = te({
                    "node_modules/vnopts/lib/handlers/unknown/index.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = (Et(), ft(vt));
                        r.__exportStar(ro(), e);
                    }
                }), Sm = te({
                    "node_modules/vnopts/lib/handlers/index.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = (Et(), ft(vt));
                        r.__exportStar(Cm(), e), r.__exportStar(to(), e), r.__exportStar(Am(), e);
                    }
                }), Ft = te({
                    "node_modules/vnopts/lib/schema.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = [
                            "default",
                            "expected",
                            "validate",
                            "deprecated",
                            "forward",
                            "redirect",
                            "overlap",
                            "preprocess",
                            "postprocess"
                        ];
                        function t1(n, u) {
                            let i = new n(u), l = Object.create(i);
                            for (let p of r)p in u && (l[p] = a2(u[p], i, s.prototype[p].length));
                            return l;
                        }
                        e.createSchema = t1;
                        var s = class {
                            static create(n) {
                                return t1(this, n);
                            }
                            default(n) {}
                            expected(n) {
                                return "nothing";
                            }
                            validate(n, u) {
                                return false;
                            }
                            deprecated(n, u) {
                                return false;
                            }
                            forward(n, u) {}
                            redirect(n, u) {}
                            overlap(n, u, i) {
                                return n;
                            }
                            preprocess(n, u) {
                                return n;
                            }
                            postprocess(n, u) {
                                return n;
                            }
                            constructor(n){
                                this.name = n.name;
                            }
                        };
                        e.Schema = s;
                        function a2(n, u, i) {
                            return typeof n == "function" ? function() {
                                for(var l = arguments.length, p = new Array(l), y = 0; y < l; y++)p[y] = arguments[y];
                                return n(...p.slice(0, i - 1), u, ...p.slice(i - 1));
                            } : ()=>n;
                        }
                    }
                }), xm = te({
                    "node_modules/vnopts/lib/schemas/alias.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = Ft(), t1 = class extends r.Schema {
                            expected(s) {
                                return s.schemas[this._sourceName].expected(s);
                            }
                            validate(s, a2) {
                                return a2.schemas[this._sourceName].validate(s, a2);
                            }
                            redirect(s, a2) {
                                return this._sourceName;
                            }
                            constructor(s){
                                super(s), this._sourceName = s.sourceName;
                            }
                        };
                        e.AliasSchema = t1;
                    }
                }), bm = te({
                    "node_modules/vnopts/lib/schemas/any.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = Ft(), t1 = class extends r.Schema {
                            expected() {
                                return "anything";
                            }
                            validate() {
                                return true;
                            }
                        };
                        e.AnySchema = t1;
                    }
                }), Tm = te({
                    "node_modules/vnopts/lib/schemas/array.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = (Et(), ft(vt)), t1 = Ft(), s = class extends t1.Schema {
                            expected(n) {
                                return `an array of ${this._valueSchema.expected(n)}`;
                            }
                            validate(n, u) {
                                if (!Array.isArray(n)) return false;
                                let i = [];
                                for (let l of n){
                                    let p = u.normalizeValidateResult(this._valueSchema.validate(l, u), l);
                                    p !== true && i.push(p.value);
                                }
                                return i.length === 0 ? true : {
                                    value: i
                                };
                            }
                            deprecated(n, u) {
                                let i = [];
                                for (let l of n){
                                    let p = u.normalizeDeprecatedResult(this._valueSchema.deprecated(l, u), l);
                                    p !== false && i.push(...p.map((y)=>{
                                        let { value: h } = y;
                                        return {
                                            value: [
                                                h
                                            ]
                                        };
                                    }));
                                }
                                return i;
                            }
                            forward(n, u) {
                                let i = [];
                                for (let l of n){
                                    let p = u.normalizeForwardResult(this._valueSchema.forward(l, u), l);
                                    i.push(...p.map(a2));
                                }
                                return i;
                            }
                            redirect(n, u) {
                                let i = [], l = [];
                                for (let p of n){
                                    let y = u.normalizeRedirectResult(this._valueSchema.redirect(p, u), p);
                                    "remain" in y && i.push(y.remain), l.push(...y.redirect.map(a2));
                                }
                                return i.length === 0 ? {
                                    redirect: l
                                } : {
                                    redirect: l,
                                    remain: i
                                };
                            }
                            overlap(n, u) {
                                return n.concat(u);
                            }
                            constructor(n){
                                var { valueSchema: u, name: i = u.name } = n, l = r.__rest(n, [
                                    "valueSchema",
                                    "name"
                                ]);
                                super(Object.assign({}, l, {
                                    name: i
                                })), this._valueSchema = u;
                            }
                        };
                        e.ArraySchema = s;
                        function a2(n) {
                            let { from: u, to: i } = n;
                            return {
                                from: [
                                    u
                                ],
                                to: i
                            };
                        }
                    }
                }), Bm = te({
                    "node_modules/vnopts/lib/schemas/boolean.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = Ft(), t1 = class extends r.Schema {
                            expected() {
                                return "true or false";
                            }
                            validate(s) {
                                return typeof s == "boolean";
                            }
                        };
                        e.BooleanSchema = t1;
                    }
                }), eu = te({
                    "node_modules/vnopts/lib/utils.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        function r(c, f2) {
                            let F = /* @__PURE__ */ Object.create(null);
                            for (let _2 of c){
                                let w = _2[f2];
                                if (F[w]) throw new Error(`Duplicate ${f2} ${JSON.stringify(w)}`);
                                F[w] = _2;
                            }
                            return F;
                        }
                        e.recordFromArray = r;
                        function t1(c, f2) {
                            let F = /* @__PURE__ */ new Map();
                            for (let _2 of c){
                                let w = _2[f2];
                                if (F.has(w)) throw new Error(`Duplicate ${f2} ${JSON.stringify(w)}`);
                                F.set(w, _2);
                            }
                            return F;
                        }
                        e.mapFromArray = t1;
                        function s() {
                            let c = /* @__PURE__ */ Object.create(null);
                            return (f2)=>{
                                let F = JSON.stringify(f2);
                                return c[F] ? true : (c[F] = true, false);
                            };
                        }
                        e.createAutoChecklist = s;
                        function a2(c, f2) {
                            let F = [], _2 = [];
                            for (let w of c)f2(w) ? F.push(w) : _2.push(w);
                            return [
                                F,
                                _2
                            ];
                        }
                        e.partition = a2;
                        function n(c) {
                            return c === Math.floor(c);
                        }
                        e.isInt = n;
                        function u(c, f2) {
                            if (c === f2) return 0;
                            let F = typeof c, _2 = typeof f2, w = [
                                "undefined",
                                "object",
                                "boolean",
                                "number",
                                "string"
                            ];
                            return F !== _2 ? w.indexOf(F) - w.indexOf(_2) : F !== "string" ? Number(c) - Number(f2) : c.localeCompare(f2);
                        }
                        e.comparePrimitive = u;
                        function i(c) {
                            return c === void 0 ? {} : c;
                        }
                        e.normalizeDefaultResult = i;
                        function l(c, f2) {
                            return c === true ? true : c === false ? {
                                value: f2
                            } : c;
                        }
                        e.normalizeValidateResult = l;
                        function p(c, f2) {
                            let F = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
                            return c === false ? false : c === true ? F ? true : [
                                {
                                    value: f2
                                }
                            ] : "value" in c ? [
                                c
                            ] : c.length === 0 ? false : c;
                        }
                        e.normalizeDeprecatedResult = p;
                        function y(c, f2) {
                            return typeof c == "string" || "key" in c ? {
                                from: f2,
                                to: c
                            } : "from" in c ? {
                                from: c.from,
                                to: c.to
                            } : {
                                from: f2,
                                to: c.to
                            };
                        }
                        e.normalizeTransferResult = y;
                        function h(c, f2) {
                            return c === void 0 ? [] : Array.isArray(c) ? c.map((F)=>y(F, f2)) : [
                                y(c, f2)
                            ];
                        }
                        e.normalizeForwardResult = h;
                        function g(c, f2) {
                            let F = h(typeof c == "object" && "redirect" in c ? c.redirect : c, f2);
                            return F.length === 0 ? {
                                remain: f2,
                                redirect: F
                            } : typeof c == "object" && "remain" in c ? {
                                remain: c.remain,
                                redirect: F
                            } : {
                                redirect: F
                            };
                        }
                        e.normalizeRedirectResult = g;
                    }
                }), Nm = te({
                    "node_modules/vnopts/lib/schemas/choice.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = Ft(), t1 = eu(), s = class extends r.Schema {
                            expected(a2) {
                                let { descriptor: n } = a2, u = Array.from(this._choices.keys()).map((p)=>this._choices.get(p)).filter((p)=>!p.deprecated).map((p)=>p.value).sort(t1.comparePrimitive).map(n.value), i = u.slice(0, -2), l = u.slice(-2);
                                return i.concat(l.join(" or ")).join(", ");
                            }
                            validate(a2) {
                                return this._choices.has(a2);
                            }
                            deprecated(a2) {
                                let n = this._choices.get(a2);
                                return n && n.deprecated ? {
                                    value: a2
                                } : false;
                            }
                            forward(a2) {
                                let n = this._choices.get(a2);
                                return n ? n.forward : void 0;
                            }
                            redirect(a2) {
                                let n = this._choices.get(a2);
                                return n ? n.redirect : void 0;
                            }
                            constructor(a2){
                                super(a2), this._choices = t1.mapFromArray(a2.choices.map((n)=>n && typeof n == "object" ? n : {
                                        value: n
                                    }), "value");
                            }
                        };
                        e.ChoiceSchema = s;
                    }
                }), no = te({
                    "node_modules/vnopts/lib/schemas/number.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = Ft(), t1 = class extends r.Schema {
                            expected() {
                                return "a number";
                            }
                            validate(s, a2) {
                                return typeof s == "number";
                            }
                        };
                        e.NumberSchema = t1;
                    }
                }), wm = te({
                    "node_modules/vnopts/lib/schemas/integer.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = eu(), t1 = no(), s = class extends t1.NumberSchema {
                            expected() {
                                return "an integer";
                            }
                            validate(a2, n) {
                                return n.normalizeValidateResult(super.validate(a2, n), a2) === true && r.isInt(a2);
                            }
                        };
                        e.IntegerSchema = s;
                    }
                }), _m = te({
                    "node_modules/vnopts/lib/schemas/string.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = Ft(), t1 = class extends r.Schema {
                            expected() {
                                return "a string";
                            }
                            validate(s) {
                                return typeof s == "string";
                            }
                        };
                        e.StringSchema = t1;
                    }
                }), Pm = te({
                    "node_modules/vnopts/lib/schemas/index.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = (Et(), ft(vt));
                        r.__exportStar(xm(), e), r.__exportStar(bm(), e), r.__exportStar(Tm(), e), r.__exportStar(Bm(), e), r.__exportStar(Nm(), e), r.__exportStar(wm(), e), r.__exportStar(no(), e), r.__exportStar(_m(), e);
                    }
                }), Im = te({
                    "node_modules/vnopts/lib/defaults.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = Za(), t1 = eo(), s = to(), a2 = ro();
                        e.defaultDescriptor = r.apiDescriptor, e.defaultUnknownHandler = a2.levenUnknownHandler, e.defaultInvalidHandler = s.commonInvalidHandler, e.defaultDeprecatedHandler = t1.commonDeprecatedHandler;
                    }
                }), km = te({
                    "node_modules/vnopts/lib/normalize.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = Im(), t1 = eu();
                        e.normalize = (a2, n, u)=>new s(n, u).normalize(a2);
                        var s = class {
                            cleanHistory() {
                                this._hasDeprecationWarned = t1.createAutoChecklist();
                            }
                            normalize(a2) {
                                let n = {}, u = [
                                    a2
                                ], i = ()=>{
                                    for(; u.length !== 0;){
                                        let l = u.shift(), p = this._applyNormalization(l, n);
                                        u.push(...p);
                                    }
                                };
                                i();
                                for (let l of Object.keys(this._utils.schemas)){
                                    let p = this._utils.schemas[l];
                                    if (!(l in n)) {
                                        let y = t1.normalizeDefaultResult(p.default(this._utils));
                                        "value" in y && u.push({
                                            [l]: y.value
                                        });
                                    }
                                }
                                i();
                                for (let l of Object.keys(this._utils.schemas)){
                                    let p = this._utils.schemas[l];
                                    l in n && (n[l] = p.postprocess(n[l], this._utils));
                                }
                                return n;
                            }
                            _applyNormalization(a2, n) {
                                let u = [], [i, l] = t1.partition(Object.keys(a2), (p)=>p in this._utils.schemas);
                                for (let p of i){
                                    let y = this._utils.schemas[p], h = y.preprocess(a2[p], this._utils), g = t1.normalizeValidateResult(y.validate(h, this._utils), h);
                                    if (g !== true) {
                                        let { value: w } = g, E = this._invalidHandler(p, w, this._utils);
                                        throw typeof E == "string" ? new Error(E) : E;
                                    }
                                    let c = (w)=>{
                                        let { from: E, to: N } = w;
                                        u.push(typeof N == "string" ? {
                                            [N]: E
                                        } : {
                                            [N.key]: N.value
                                        });
                                    }, f2 = (w)=>{
                                        let { value: E, redirectTo: N } = w, x = t1.normalizeDeprecatedResult(y.deprecated(E, this._utils), h, true);
                                        if (x !== false) if (x === true) this._hasDeprecationWarned(p) || this._utils.logger.warn(this._deprecatedHandler(p, N, this._utils));
                                        else for (let { value: I } of x){
                                            let P = {
                                                key: p,
                                                value: I
                                            };
                                            if (!this._hasDeprecationWarned(P)) {
                                                let $ = typeof N == "string" ? {
                                                    key: N,
                                                    value: I
                                                } : N;
                                                this._utils.logger.warn(this._deprecatedHandler(P, $, this._utils));
                                            }
                                        }
                                    };
                                    t1.normalizeForwardResult(y.forward(h, this._utils), h).forEach(c);
                                    let _2 = t1.normalizeRedirectResult(y.redirect(h, this._utils), h);
                                    if (_2.redirect.forEach(c), "remain" in _2) {
                                        let w = _2.remain;
                                        n[p] = p in n ? y.overlap(n[p], w, this._utils) : w, f2({
                                            value: w
                                        });
                                    }
                                    for (let { from: w, to: E } of _2.redirect)f2({
                                        value: w,
                                        redirectTo: E
                                    });
                                }
                                for (let p of l){
                                    let y = a2[p], h = this._unknownHandler(p, y, this._utils);
                                    if (h) for (let g of Object.keys(h)){
                                        let c = {
                                            [g]: h[g]
                                        };
                                        g in this._utils.schemas ? u.push(c) : Object.assign(n, c);
                                    }
                                }
                                return u;
                            }
                            constructor(a2, n){
                                let { logger: u = console, descriptor: i = r.defaultDescriptor, unknown: l = r.defaultUnknownHandler, invalid: p = r.defaultInvalidHandler, deprecated: y = r.defaultDeprecatedHandler } = n || {};
                                this._utils = {
                                    descriptor: i,
                                    logger: u || {
                                        warn: ()=>{}
                                    },
                                    schemas: t1.recordFromArray(a2, "name"),
                                    normalizeDefaultResult: t1.normalizeDefaultResult,
                                    normalizeDeprecatedResult: t1.normalizeDeprecatedResult,
                                    normalizeForwardResult: t1.normalizeForwardResult,
                                    normalizeRedirectResult: t1.normalizeRedirectResult,
                                    normalizeValidateResult: t1.normalizeValidateResult
                                }, this._unknownHandler = l, this._invalidHandler = p, this._deprecatedHandler = y, this.cleanHistory();
                            }
                        };
                        e.Normalizer = s;
                    }
                }), Lm = te({
                    "node_modules/vnopts/lib/index.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = (Et(), ft(vt));
                        r.__exportStar(vm(), e), r.__exportStar(Sm(), e), r.__exportStar(Pm(), e), r.__exportStar(km(), e), r.__exportStar(Ft(), e);
                    }
                }), Om = te({
                    "src/main/options-normalizer.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Lm(), s = lt(), a2 = {
                            key: (g)=>g.length === 1 ? `-${g}` : `--${g}`,
                            value: (g)=>t1.apiDescriptor.value(g),
                            pair: (g)=>{
                                let { key: c, value: f2 } = g;
                                return f2 === false ? `--no-${c}` : f2 === true ? a2.key(c) : f2 === "" ? `${a2.key(c)} without an argument` : `${a2.key(c)}=${f2}`;
                            }
                        }, n = (g)=>{
                            let { colorsModule: c, levenshteinDistance: f2 } = g;
                            return class extends t1.ChoiceSchema {
                                preprocess(_2, w) {
                                    if (typeof _2 == "string" && _2.length > 0 && !this._flags.includes(_2)) {
                                        let E = this._flags.find((N)=>f2(N, _2) < 3);
                                        if (E) return w.logger.warn([
                                            `Unknown flag ${c.yellow(w.descriptor.value(_2))},`,
                                            `did you mean ${c.blue(w.descriptor.value(E))}?`
                                        ].join(" ")), E;
                                    }
                                    return _2;
                                }
                                expected() {
                                    return "a flag";
                                }
                                constructor(_2){
                                    let { name: w, flags: E } = _2;
                                    super({
                                        name: w,
                                        choices: E
                                    }), this._flags = [
                                        ...E
                                    ].sort();
                                }
                            };
                        }, u;
                        function i(g, c) {
                            let { logger: f2 = false, isCLI: F = false, passThrough: _2 = false, colorsModule: w = null, levenshteinDistance: E = null } = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, N = _2 ? Array.isArray(_2) ? (T, m)=>_2.includes(T) ? {
                                    [T]: m
                                } : void 0 : (T, m)=>({
                                    [T]: m
                                }) : (T, m, C)=>{
                                let o = C.schemas, { _: d } = o, v = Hn(o, vD);
                                return t1.levenUnknownHandler(T, m, Object.assign(Object.assign({}, C), {}, {
                                    schemas: v
                                }));
                            }, x = F ? a2 : t1.apiDescriptor, I = l(c, {
                                isCLI: F,
                                colorsModule: w,
                                levenshteinDistance: E
                            }), P = new t1.Normalizer(I, {
                                logger: f2,
                                unknown: N,
                                descriptor: x
                            }), $ = f2 !== false;
                            $ && u && (P._hasDeprecationWarned = u);
                            let D = P.normalize(g);
                            return $ && (u = P._hasDeprecationWarned), F && D["plugin-search"] === false && (D["plugin-search-dir"] = false), D;
                        }
                        function l(g, c) {
                            let { isCLI: f2, colorsModule: F, levenshteinDistance: _2 } = c, w = [];
                            f2 && w.push(t1.AnySchema.create({
                                name: "_"
                            }));
                            for (let E of g)w.push(p(E, {
                                isCLI: f2,
                                optionInfos: g,
                                colorsModule: F,
                                levenshteinDistance: _2
                            })), E.alias && f2 && w.push(t1.AliasSchema.create({
                                name: E.alias,
                                sourceName: E.name
                            }));
                            return w;
                        }
                        function p(g, c) {
                            let { isCLI: f2, optionInfos: F, colorsModule: _2, levenshteinDistance: w } = c, { name: E } = g;
                            if (E === "plugin-search-dir" || E === "pluginSearchDirs") return t1.AnySchema.create({
                                name: E,
                                preprocess (P) {
                                    return P === false || (P = Array.isArray(P) ? P : [
                                        P
                                    ]), P;
                                },
                                validate (P) {
                                    return P === false ? true : P.every(($)=>typeof $ == "string");
                                },
                                expected () {
                                    return "false or paths to plugin search dir";
                                }
                            });
                            let N = {
                                name: E
                            }, x, I = {};
                            switch(g.type){
                                case "int":
                                    x = t1.IntegerSchema, f2 && (N.preprocess = Number);
                                    break;
                                case "string":
                                    x = t1.StringSchema;
                                    break;
                                case "choice":
                                    x = t1.ChoiceSchema, N.choices = g.choices.map((P)=>typeof P == "object" && P.redirect ? Object.assign(Object.assign({}, P), {}, {
                                            redirect: {
                                                to: {
                                                    key: g.name,
                                                    value: P.redirect
                                                }
                                            }
                                        }) : P);
                                    break;
                                case "boolean":
                                    x = t1.BooleanSchema;
                                    break;
                                case "flag":
                                    x = n({
                                        colorsModule: _2,
                                        levenshteinDistance: w
                                    }), N.flags = F.flatMap((P)=>[
                                            P.alias,
                                            P.description && P.name,
                                            P.oppositeDescription && `no-${P.name}`
                                        ].filter(Boolean));
                                    break;
                                case "path":
                                    x = t1.StringSchema;
                                    break;
                                default:
                                    throw new Error(`Unexpected type ${g.type}`);
                            }
                            if (g.exception ? N.validate = (P, $, D)=>g.exception(P) || $.validate(P, D) : N.validate = (P, $, D)=>P === void 0 || $.validate(P, D), g.redirect && (I.redirect = (P)=>P ? {
                                    to: {
                                        key: g.redirect.option,
                                        value: g.redirect.value
                                    }
                                } : void 0), g.deprecated && (I.deprecated = true), f2 && !g.array) {
                                let P = N.preprocess || (($)=>$);
                                N.preprocess = ($, D, T)=>D.preprocess(P(Array.isArray($) ? s($) : $), T);
                            }
                            return g.array ? t1.ArraySchema.create(Object.assign(Object.assign(Object.assign({}, f2 ? {
                                preprocess: (P)=>Array.isArray(P) ? P : [
                                        P
                                    ]
                            } : {}), I), {}, {
                                valueSchema: x.create(N)
                            })) : x.create(Object.assign(Object.assign({}, N), I));
                        }
                        function y(g, c, f2) {
                            return i(g, c, f2);
                        }
                        function h(g, c, f2) {
                            return i(g, c, Object.assign({
                                isCLI: true
                            }, f2));
                        }
                        r.exports = {
                            normalizeApiOptions: y,
                            normalizeCliOptions: h
                        };
                    }
                }), ut = te({
                    "src/language-js/loc.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Kn();
                        function s(l) {
                            var p, y;
                            let h = l.range ? l.range[0] : l.start, g = (p = (y = l.declaration) === null || y === void 0 ? void 0 : y.decorators) !== null && p !== void 0 ? p : l.decorators;
                            return t1(g) ? Math.min(s(g[0]), h) : h;
                        }
                        function a2(l) {
                            return l.range ? l.range[1] : l.end;
                        }
                        function n(l, p) {
                            let y = s(l);
                            return Number.isInteger(y) && y === s(p);
                        }
                        function u(l, p) {
                            let y = a2(l);
                            return Number.isInteger(y) && y === a2(p);
                        }
                        function i(l, p) {
                            return n(l, p) && u(l, p);
                        }
                        r.exports = {
                            locStart: s,
                            locEnd: a2,
                            hasSameLocStart: n,
                            hasSameLoc: i
                        };
                    }
                }), jm = te({
                    "src/main/load-parser.js" (e, r) {
                        ne(), r.exports = ()=>{};
                    }
                }), qm = te({
                    "scripts/build/shims/babel-highlight.cjs" (e, r) {
                        "use strict";
                        ne();
                        var t1 = kr(), s = {
                            shouldHighlight: ()=>false,
                            getChalk: ()=>t1
                        };
                        r.exports = s;
                    }
                }), Mm = te({
                    "node_modules/@babel/code-frame/lib/index.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        }), e.codeFrameColumns = u, e.default = i;
                        var r = qm(), t1 = false;
                        function s(l) {
                            return {
                                gutter: l.grey,
                                marker: l.red.bold,
                                message: l.red.bold
                            };
                        }
                        var a2 = /\r\n|[\n\r\u2028\u2029]/;
                        function n(l, p, y) {
                            let h = Object.assign({
                                column: 0,
                                line: -1
                            }, l.start), g = Object.assign({}, h, l.end), { linesAbove: c = 2, linesBelow: f2 = 3 } = y || {}, F = h.line, _2 = h.column, w = g.line, E = g.column, N = Math.max(F - (c + 1), 0), x = Math.min(p.length, w + f2);
                            F === -1 && (N = 0), w === -1 && (x = p.length);
                            let I = w - F, P = {};
                            if (I) for(let $ = 0; $ <= I; $++){
                                let D = $ + F;
                                if (!_2) P[D] = true;
                                else if ($ === 0) {
                                    let T = p[D - 1].length;
                                    P[D] = [
                                        _2,
                                        T - _2 + 1
                                    ];
                                } else if ($ === I) P[D] = [
                                    0,
                                    E
                                ];
                                else {
                                    let T = p[D - $].length;
                                    P[D] = [
                                        0,
                                        T
                                    ];
                                }
                            }
                            else _2 === E ? _2 ? P[F] = [
                                _2,
                                0
                            ] : P[F] = true : P[F] = [
                                _2,
                                E - _2
                            ];
                            return {
                                start: N,
                                end: x,
                                markerLines: P
                            };
                        }
                        function u(l, p) {
                            let y = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, h = (y.highlightCode || y.forceColor) && (0, r.shouldHighlight)(y), g = (0, r.getChalk)(y), c = s(g), f2 = ($, D)=>h ? $(D) : D, F = l.split(a2), { start: _2, end: w, markerLines: E } = n(p, F, y), N = p.start && typeof p.start.column == "number", x = String(w).length, P = (h ? (0, r.default)(l, y) : l).split(a2, w).slice(_2, w).map(($, D)=>{
                                let T = _2 + 1 + D, C = ` ${` ${T}`.slice(-x)} |`, o = E[T], d = !E[T + 1];
                                if (o) {
                                    let v = "";
                                    if (Array.isArray(o)) {
                                        let S = $.slice(0, Math.max(o[0] - 1, 0)).replace(/[^\t]/g, " "), b = o[1] || 1;
                                        v = [
                                            `
 `,
                                            f2(c.gutter, C.replace(/\d/g, " ")),
                                            " ",
                                            S,
                                            f2(c.marker, "^").repeat(b)
                                        ].join(""), d && y.message && (v += " " + f2(c.message, y.message));
                                    }
                                    return [
                                        f2(c.marker, ">"),
                                        f2(c.gutter, C),
                                        $.length > 0 ? ` ${$}` : "",
                                        v
                                    ].join("");
                                } else return ` ${f2(c.gutter, C)}${$.length > 0 ? ` ${$}` : ""}`;
                            }).join(`
`);
                            return y.message && !N && (P = `${" ".repeat(x + 1)}${y.message}
${P}`), h ? g.reset(P) : P;
                        }
                        function i(l, p, y) {
                            let h = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
                            if (!t1) {
                                t1 = true;
                                let c = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
                                if (wt.emitWarning) wt.emitWarning(c, "DeprecationWarning");
                                else {
                                    let f2 = new Error(c);
                                    f2.name = "DeprecationWarning", console.warn(new Error(c));
                                }
                            }
                            return y = Math.max(y, 0), u(l, {
                                start: {
                                    column: y,
                                    line: p
                                }
                            }, h);
                        }
                    }
                }), tu = te({
                    "src/main/parser.js" (e, r) {
                        "use strict";
                        ne();
                        var { ConfigError: t1 } = Qt(), s = ut(), a2 = jm(), { locStart: n, locEnd: u } = s, i = Object.getOwnPropertyNames, l = Object.getOwnPropertyDescriptor;
                        function p(g) {
                            let c = {};
                            for (let f2 of g.plugins)if (f2.parsers) for (let F of i(f2.parsers))Object.defineProperty(c, F, l(f2.parsers, F));
                            return c;
                        }
                        function y(g) {
                            let c = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : p(g);
                            if (typeof g.parser == "function") return {
                                parse: g.parser,
                                astFormat: "estree",
                                locStart: n,
                                locEnd: u
                            };
                            if (typeof g.parser == "string") {
                                if (Object.prototype.hasOwnProperty.call(c, g.parser)) return c[g.parser];
                                throw new t1(`Couldn't resolve parser "${g.parser}". Parsers must be explicitly added to the standalone bundle.`);
                            }
                        }
                        function h(g, c) {
                            let f2 = p(c), F = Object.defineProperties({}, Object.fromEntries(Object.keys(f2).map((w)=>[
                                    w,
                                    {
                                        enumerable: true,
                                        get () {
                                            return f2[w].parse;
                                        }
                                    }
                                ]))), _2 = y(c, f2);
                            try {
                                return _2.preprocess && (g = _2.preprocess(g, c)), {
                                    text: g,
                                    ast: _2.parse(g, F, c)
                                };
                            } catch (w) {
                                let { loc: E } = w;
                                if (E) {
                                    let { codeFrameColumns: N } = Mm();
                                    throw w.codeFrame = N(g, E, {
                                        highlightCode: true
                                    }), w.message += `
` + w.codeFrame, w;
                                }
                                throw w;
                            }
                        }
                        r.exports = {
                            parse: h,
                            resolveParser: y
                        };
                    }
                }), uo = te({
                    "src/main/options.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = ZD(), { UndefinedParserError: s } = Qt(), { getSupportInfo: a2 } = Xn(), n = Om(), { resolveParser: u } = tu(), i = {
                            astFormat: "estree",
                            printer: {},
                            originalText: void 0,
                            locStart: null,
                            locEnd: null
                        };
                        function l(h) {
                            let g = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, c = Object.assign({}, h), f2 = a2({
                                plugins: h.plugins,
                                showUnreleased: true,
                                showDeprecated: true
                            }).options, F = Object.assign(Object.assign({}, i), Object.fromEntries(f2.filter((x)=>x.default !== void 0).map((x)=>[
                                    x.name,
                                    x.default
                                ])));
                            if (!c.parser) {
                                if (!c.filepath) (g.logger || console).warn("No parser and no filepath given, using 'babel' the parser now but this will throw an error in the future. Please specify a parser or a filepath so one can be inferred."), c.parser = "babel";
                                else if (c.parser = y(c.filepath, c.plugins), !c.parser) throw new s(`No parser could be inferred for file: ${c.filepath}`);
                            }
                            let _2 = u(n.normalizeApiOptions(c, [
                                f2.find((x)=>x.name === "parser")
                            ], {
                                passThrough: true,
                                logger: false
                            }));
                            c.astFormat = _2.astFormat, c.locEnd = _2.locEnd, c.locStart = _2.locStart;
                            let w = p(c);
                            c.printer = w.printers[c.astFormat];
                            let E = Object.fromEntries(f2.filter((x)=>x.pluginDefaults && x.pluginDefaults[w.name] !== void 0).map((x)=>[
                                    x.name,
                                    x.pluginDefaults[w.name]
                                ])), N = Object.assign(Object.assign({}, F), E);
                            for (let [x, I] of Object.entries(N))(c[x] === null || c[x] === void 0) && (c[x] = I);
                            return c.parser === "json" && (c.trailingComma = "none"), n.normalizeApiOptions(c, f2, Object.assign({
                                passThrough: Object.keys(i)
                            }, g));
                        }
                        function p(h) {
                            let { astFormat: g } = h;
                            if (!g) throw new Error("getPlugin() requires astFormat to be set");
                            let c = h.plugins.find((f2)=>f2.printers && f2.printers[g]);
                            if (!c) throw new Error(`Couldn't find plugin for AST format "${g}"`);
                            return c;
                        }
                        function y(h, g) {
                            let c = t1.basename(h).toLowerCase(), F = a2({
                                plugins: g
                            }).languages.filter((_2)=>_2.since !== null).find((_2)=>_2.extensions && _2.extensions.some((w)=>c.endsWith(w)) || _2.filenames && _2.filenames.some((w)=>w.toLowerCase() === c));
                            return F && F.parsers[0];
                        }
                        r.exports = {
                            normalize: l,
                            hiddenDefaults: i,
                            inferParser: y
                        };
                    }
                }), Rm = te({
                    "src/main/massage-ast.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s, a2, n) {
                            if (Array.isArray(s)) return s.map((p)=>t1(p, a2, n)).filter(Boolean);
                            if (!s || typeof s != "object") return s;
                            let u = a2.printer.massageAstNode, i;
                            u && u.ignoredProperties ? i = u.ignoredProperties : i = /* @__PURE__ */ new Set();
                            let l = {};
                            for (let [p, y] of Object.entries(s))!i.has(p) && typeof y != "function" && (l[p] = t1(y, a2, s));
                            if (u) {
                                let p = u(s, l, n);
                                if (p === null) return;
                                if (p) return p;
                            }
                            return l;
                        }
                        r.exports = t1;
                    }
                }), Zt = te({
                    "scripts/build/shims/assert.cjs" (e, r) {
                        "use strict";
                        ne();
                        var t1 = ()=>{};
                        t1.ok = t1, t1.strictEqual = t1, r.exports = t1;
                    }
                }), et = te({
                    "src/main/comments.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Zt(), { builders: { line: s, hardline: a2, breakParent: n, indent: u, lineSuffix: i, join: l, cursor: p } } = qe(), { hasNewline: y, skipNewline: h, skipSpaces: g, isPreviousLineEmpty: c, addLeadingComment: f2, addDanglingComment: F, addTrailingComment: _2 } = Ue(), w = /* @__PURE__ */ new WeakMap();
                        function E(k, M, R) {
                            if (!k) return;
                            let { printer: q, locStart: J, locEnd: L } = M;
                            if (R) {
                                if (q.canAttachComment && q.canAttachComment(k)) {
                                    let V;
                                    for(V = R.length - 1; V >= 0 && !(J(R[V]) <= J(k) && L(R[V]) <= L(k)); --V);
                                    R.splice(V + 1, 0, k);
                                    return;
                                }
                            } else if (w.has(k)) return w.get(k);
                            let Q = q.getCommentChildNodes && q.getCommentChildNodes(k, M) || typeof k == "object" && Object.entries(k).filter((V)=>{
                                let [j] = V;
                                return j !== "enclosingNode" && j !== "precedingNode" && j !== "followingNode" && j !== "tokens" && j !== "comments" && j !== "parent";
                            }).map((V)=>{
                                let [, j] = V;
                                return j;
                            });
                            if (Q) {
                                R || (R = [], w.set(k, R));
                                for (let V of Q)E(V, M, R);
                                return R;
                            }
                        }
                        function N(k, M, R, q) {
                            let { locStart: J, locEnd: L } = R, Q = J(M), V = L(M), j = E(k, R), Y, ie, ee = 0, ce = j.length;
                            for(; ee < ce;){
                                let W = ee + ce >> 1, K = j[W], de = J(K), ue = L(K);
                                if (de <= Q && V <= ue) return N(K, M, R, K);
                                if (ue <= Q) {
                                    Y = K, ee = W + 1;
                                    continue;
                                }
                                if (V <= de) {
                                    ie = K, ce = W;
                                    continue;
                                }
                                throw new Error("Comment location overlaps with node location");
                            }
                            if (q && q.type === "TemplateLiteral") {
                                let { quasis: W } = q, K = C(W, M, R);
                                Y && C(W, Y, R) !== K && (Y = null), ie && C(W, ie, R) !== K && (ie = null);
                            }
                            return {
                                enclosingNode: q,
                                precedingNode: Y,
                                followingNode: ie
                            };
                        }
                        var x = ()=>false;
                        function I(k, M, R, q) {
                            if (!Array.isArray(k)) return;
                            let J = [], { locStart: L, locEnd: Q, printer: { handleComments: V = {} } } = q, { avoidAstMutation: j, ownLine: Y = x, endOfLine: ie = x, remaining: ee = x } = V, ce = k.map((W, K)=>Object.assign(Object.assign({}, N(M, W, q)), {}, {
                                    comment: W,
                                    text: R,
                                    options: q,
                                    ast: M,
                                    isLastComment: k.length - 1 === K
                                }));
                            for (let [W, K] of ce.entries()){
                                let { comment: de, precedingNode: ue, enclosingNode: Fe, followingNode: z, text: U, options: Z, ast: se, isLastComment: fe } = K;
                                if (Z.parser === "json" || Z.parser === "json5" || Z.parser === "__js_expression" || Z.parser === "__vue_expression" || Z.parser === "__vue_ts_expression") {
                                    if (L(de) - L(se) <= 0) {
                                        f2(se, de);
                                        continue;
                                    }
                                    if (Q(de) - Q(se) >= 0) {
                                        _2(se, de);
                                        continue;
                                    }
                                }
                                let ge;
                                if (j ? ge = [
                                    K
                                ] : (de.enclosingNode = Fe, de.precedingNode = ue, de.followingNode = z, ge = [
                                    de,
                                    U,
                                    Z,
                                    se,
                                    fe
                                ]), $(U, Z, ce, W)) de.placement = "ownLine", Y(...ge) || (z ? f2(z, de) : ue ? _2(ue, de) : F(Fe || se, de));
                                else if (D(U, Z, ce, W)) de.placement = "endOfLine", ie(...ge) || (ue ? _2(ue, de) : z ? f2(z, de) : F(Fe || se, de));
                                else if (de.placement = "remaining", !ee(...ge)) if (ue && z) {
                                    let he = J.length;
                                    he > 0 && J[he - 1].followingNode !== z && T(J, U, Z), J.push(K);
                                } else ue ? _2(ue, de) : z ? f2(z, de) : F(Fe || se, de);
                            }
                            if (T(J, R, q), !j) for (let W of k)delete W.precedingNode, delete W.enclosingNode, delete W.followingNode;
                        }
                        var P = (k)=>!/[\S\n\u2028\u2029]/.test(k);
                        function $(k, M, R, q) {
                            let { comment: J, precedingNode: L } = R[q], { locStart: Q, locEnd: V } = M, j = Q(J);
                            if (L) for(let Y = q - 1; Y >= 0; Y--){
                                let { comment: ie, precedingNode: ee } = R[Y];
                                if (ee !== L || !P(k.slice(V(ie), j))) break;
                                j = Q(ie);
                            }
                            return y(k, j, {
                                backwards: true
                            });
                        }
                        function D(k, M, R, q) {
                            let { comment: J, followingNode: L } = R[q], { locStart: Q, locEnd: V } = M, j = V(J);
                            if (L) for(let Y = q + 1; Y < R.length; Y++){
                                let { comment: ie, followingNode: ee } = R[Y];
                                if (ee !== L || !P(k.slice(j, Q(ie)))) break;
                                j = V(ie);
                            }
                            return y(k, j);
                        }
                        function T(k, M, R) {
                            let q = k.length;
                            if (q === 0) return;
                            let { precedingNode: J, followingNode: L, enclosingNode: Q } = k[0], V = R.printer.getGapRegex && R.printer.getGapRegex(Q) || /^[\s(]*$/, j = R.locStart(L), Y;
                            for(Y = q; Y > 0; --Y){
                                let { comment: ie, precedingNode: ee, followingNode: ce } = k[Y - 1];
                                t1.strictEqual(ee, J), t1.strictEqual(ce, L);
                                let W = M.slice(R.locEnd(ie), j);
                                if (V.test(W)) j = R.locStart(ie);
                                else break;
                            }
                            for (let [ie, { comment: ee }] of k.entries())ie < Y ? _2(J, ee) : f2(L, ee);
                            for (let ie of [
                                J,
                                L
                            ])ie.comments && ie.comments.length > 1 && ie.comments.sort((ee, ce)=>R.locStart(ee) - R.locStart(ce));
                            k.length = 0;
                        }
                        function m(k, M) {
                            let R = k.getValue();
                            return R.printed = true, M.printer.printComment(k, M);
                        }
                        function C(k, M, R) {
                            let q = R.locStart(M) - 1;
                            for(let J = 1; J < k.length; ++J)if (q < R.locStart(k[J])) return J - 1;
                            return 0;
                        }
                        function o(k, M) {
                            let R = k.getValue(), q = [
                                m(k, M)
                            ], { printer: J, originalText: L, locStart: Q, locEnd: V } = M;
                            if (J.isBlockComment && J.isBlockComment(R)) {
                                let ie = y(L, V(R)) ? y(L, Q(R), {
                                    backwards: true
                                }) ? a2 : s : " ";
                                q.push(ie);
                            } else q.push(a2);
                            let Y = h(L, g(L, V(R)));
                            return Y !== false && y(L, Y) && q.push(a2), q;
                        }
                        function d(k, M) {
                            let R = k.getValue(), q = m(k, M), { printer: J, originalText: L, locStart: Q } = M, V = J.isBlockComment && J.isBlockComment(R);
                            if (y(L, Q(R), {
                                backwards: true
                            })) {
                                let Y = c(L, R, Q);
                                return i([
                                    a2,
                                    Y ? a2 : "",
                                    q
                                ]);
                            }
                            let j = [
                                " ",
                                q
                            ];
                            return V || (j = [
                                i(j),
                                n
                            ]), j;
                        }
                        function v(k, M, R, q) {
                            let J = [], L = k.getValue();
                            return !L || !L.comments || (k.each(()=>{
                                let Q = k.getValue();
                                !Q.leading && !Q.trailing && (!q || q(Q)) && J.push(m(k, M));
                            }, "comments"), J.length === 0) ? "" : R ? l(a2, J) : u([
                                a2,
                                l(a2, J)
                            ]);
                        }
                        function S(k, M, R) {
                            let q = k.getValue();
                            if (!q) return {};
                            let J = q.comments || [];
                            R && (J = J.filter((j)=>!R.has(j)));
                            let L = q === M.cursorNode;
                            if (J.length === 0) {
                                let j = L ? p : "";
                                return {
                                    leading: j,
                                    trailing: j
                                };
                            }
                            let Q = [], V = [];
                            return k.each(()=>{
                                let j = k.getValue();
                                if (R && R.has(j)) return;
                                let { leading: Y, trailing: ie } = j;
                                Y ? Q.push(o(k, M)) : ie && V.push(d(k, M));
                            }, "comments"), L && (Q.unshift(p), V.push(p)), {
                                leading: Q,
                                trailing: V
                            };
                        }
                        function b(k, M, R, q) {
                            let { leading: J, trailing: L } = S(k, R, q);
                            return !J && !L ? M : [
                                J,
                                M,
                                L
                            ];
                        }
                        function B(k) {
                            if (k) for (let M of k){
                                if (!M.printed) throw new Error('Comment "' + M.value.trim() + '" was not printed. Please report this error!');
                                delete M.printed;
                            }
                        }
                        r.exports = {
                            attach: I,
                            printComments: b,
                            printCommentsSeparately: S,
                            printDanglingComments: v,
                            getSortedChildNodes: E,
                            ensureAllCommentsPrinted: B
                        };
                    }
                }), $m = te({
                    "src/common/ast-path.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = lt();
                        function s(u, i) {
                            let l = a2(u.stack, i);
                            return l === -1 ? null : u.stack[l];
                        }
                        function a2(u, i) {
                            for(let l = u.length - 1; l >= 0; l -= 2){
                                let p = u[l];
                                if (p && !Array.isArray(p) && --i < 0) return l;
                            }
                            return -1;
                        }
                        var n = class {
                            getName() {
                                let { stack: u } = this, { length: i } = u;
                                return i > 1 ? u[i - 2] : null;
                            }
                            getValue() {
                                return t1(this.stack);
                            }
                            getNode() {
                                let u = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
                                return s(this, u);
                            }
                            getParentNode() {
                                let u = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
                                return s(this, u + 1);
                            }
                            call(u) {
                                let { stack: i } = this, { length: l } = i, p = t1(i);
                                for(var y = arguments.length, h = new Array(y > 1 ? y - 1 : 0), g = 1; g < y; g++)h[g - 1] = arguments[g];
                                for (let f2 of h)p = p[f2], i.push(f2, p);
                                let c = u(this);
                                return i.length = l, c;
                            }
                            callParent(u) {
                                let i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0, l = a2(this.stack, i + 1), p = this.stack.splice(l + 1), y = u(this);
                                return this.stack.push(...p), y;
                            }
                            each(u) {
                                let { stack: i } = this, { length: l } = i, p = t1(i);
                                for(var y = arguments.length, h = new Array(y > 1 ? y - 1 : 0), g = 1; g < y; g++)h[g - 1] = arguments[g];
                                for (let c of h)p = p[c], i.push(c, p);
                                for(let c = 0; c < p.length; ++c)i.push(c, p[c]), u(this, c, p), i.length -= 2;
                                i.length = l;
                            }
                            map(u) {
                                let i = [];
                                for(var l = arguments.length, p = new Array(l > 1 ? l - 1 : 0), y = 1; y < l; y++)p[y - 1] = arguments[y];
                                return this.each((h, g, c)=>{
                                    i[g] = u(h, g, c);
                                }, ...p), i;
                            }
                            try(u) {
                                let { stack: i } = this, l = [
                                    ...i
                                ];
                                try {
                                    return u();
                                } finally{
                                    i.length = 0, i.push(...l);
                                }
                            }
                            match() {
                                let u = this.stack.length - 1, i = null, l = this.stack[u--];
                                for(var p = arguments.length, y = new Array(p), h = 0; h < p; h++)y[h] = arguments[h];
                                for (let g of y){
                                    if (l === void 0) return false;
                                    let c = null;
                                    if (typeof i == "number" && (c = i, i = this.stack[u--], l = this.stack[u--]), g && !g(l, i, c)) return false;
                                    i = this.stack[u--], l = this.stack[u--];
                                }
                                return true;
                            }
                            findAncestor(u) {
                                let i = this.stack.length - 1, l = null, p = this.stack[i--];
                                for(; p;){
                                    let y = null;
                                    if (typeof l == "number" && (y = l, l = this.stack[i--], p = this.stack[i--]), l !== null && u(p, l, y)) return p;
                                    l = this.stack[i--], p = this.stack[i--];
                                }
                            }
                            constructor(u){
                                this.stack = [
                                    u
                                ];
                            }
                        };
                        r.exports = n;
                    }
                }), Vm = te({
                    "src/main/multiparser.js" (e, r) {
                        "use strict";
                        ne();
                        var { utils: { stripTrailingHardline: t1 } } = qe(), { normalize: s } = uo(), a2 = et();
                        function n(i, l, p, y) {
                            if (p.printer.embed && p.embeddedLanguageFormatting === "auto") return p.printer.embed(i, l, (h, g, c)=>u(h, g, p, y, c), p);
                        }
                        function u(i, l, p, y) {
                            let { stripTrailingHardline: h = false } = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : {}, g = s(Object.assign(Object.assign(Object.assign({}, p), l), {}, {
                                parentParser: p.parser,
                                originalText: i
                            }), {
                                passThrough: true
                            }), c = tu().parse(i, g), { ast: f2 } = c;
                            i = c.text;
                            let F = f2.comments;
                            delete f2.comments, a2.attach(F, f2, i, g), g[Symbol.for("comments")] = F || [], g[Symbol.for("tokens")] = f2.tokens || [];
                            let _2 = y(f2, g);
                            return a2.ensureAllCommentsPrinted(F), h ? typeof _2 == "string" ? _2.replace(/(?:\r?\n)*$/, "") : t1(_2) : _2;
                        }
                        r.exports = {
                            printSubtree: n
                        };
                    }
                }), Wm = te({
                    "src/main/ast-to-doc.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = $m(), { builders: { hardline: s, addAlignmentToDoc: a2 }, utils: { propagateBreaks: n } } = qe(), { printComments: u } = et(), i = Vm();
                        function l(h, g) {
                            let c = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0, { printer: f2 } = g;
                            f2.preprocess && (h = f2.preprocess(h, g));
                            let F = /* @__PURE__ */ new Map(), _2 = new t1(h), w = E();
                            return c > 0 && (w = a2([
                                s,
                                w
                            ], c, g.tabWidth)), n(w), w;
                            function E(x, I) {
                                return x === void 0 || x === _2 ? N(I) : Array.isArray(x) ? _2.call(()=>N(I), ...x) : _2.call(()=>N(I), x);
                            }
                            function N(x) {
                                let I = _2.getValue(), P = I && typeof I == "object" && x === void 0;
                                if (P && F.has(I)) return F.get(I);
                                let $ = y(_2, g, E, x);
                                return P && F.set(I, $), $;
                            }
                        }
                        function p(h, g) {
                            let { originalText: c, [Symbol.for("comments")]: f2, locStart: F, locEnd: _2 } = g, w = F(h), E = _2(h), N = /* @__PURE__ */ new Set();
                            for (let x of f2)F(x) >= w && _2(x) <= E && (x.printed = true, N.add(x));
                            return {
                                doc: c.slice(w, E),
                                printedComments: N
                            };
                        }
                        function y(h, g, c, f2) {
                            let F = h.getValue(), { printer: _2 } = g, w, E;
                            if (_2.hasPrettierIgnore && _2.hasPrettierIgnore(h)) ({ doc: w, printedComments: E } = p(F, g));
                            else {
                                if (F) try {
                                    w = i.printSubtree(h, c, g, l);
                                } catch (N) {
                                    if (globalThis.PRETTIER_DEBUG) throw N;
                                }
                                w || (w = _2.print(h, g, c, f2));
                            }
                            return (!_2.willPrintOwnComments || !_2.willPrintOwnComments(h, g)) && (w = u(h, w, g, E)), w;
                        }
                        r.exports = l;
                    }
                }), Hm = te({
                    "src/main/range-util.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Zt(), s = et(), a2 = (f2)=>{
                            let { parser: F } = f2;
                            return F === "json" || F === "json5" || F === "json-stringify";
                        };
                        function n(f2, F) {
                            let _2 = [
                                f2.node,
                                ...f2.parentNodes
                            ], w = /* @__PURE__ */ new Set([
                                F.node,
                                ...F.parentNodes
                            ]);
                            return _2.find((E)=>y.has(E.type) && w.has(E));
                        }
                        function u(f2) {
                            let F = f2.length - 1;
                            for(;;){
                                let _2 = f2[F];
                                if (_2 && (_2.type === "Program" || _2.type === "File")) F--;
                                else break;
                            }
                            return f2.slice(0, F + 1);
                        }
                        function i(f2, F, _2) {
                            let { locStart: w, locEnd: E } = _2, N = f2.node, x = F.node;
                            if (N === x) return {
                                startNode: N,
                                endNode: x
                            };
                            let I = w(f2.node);
                            for (let $ of u(F.parentNodes))if (w($) >= I) x = $;
                            else break;
                            let P = E(F.node);
                            for (let $ of u(f2.parentNodes)){
                                if (E($) <= P) N = $;
                                else break;
                                if (N === x) break;
                            }
                            return {
                                startNode: N,
                                endNode: x
                            };
                        }
                        function l(f2, F, _2, w) {
                            let E = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : [], N = arguments.length > 5 ? arguments[5] : void 0, { locStart: x, locEnd: I } = _2, P = x(f2), $ = I(f2);
                            if (!(F > $ || F < P || N === "rangeEnd" && F === P || N === "rangeStart" && F === $)) {
                                for (let D of s.getSortedChildNodes(f2, _2)){
                                    let T = l(D, F, _2, w, [
                                        f2,
                                        ...E
                                    ], N);
                                    if (T) return T;
                                }
                                if (!w || w(f2, E[0])) return {
                                    node: f2,
                                    parentNodes: E
                                };
                            }
                        }
                        function p(f2, F) {
                            return F !== "DeclareExportDeclaration" && f2 !== "TypeParameterDeclaration" && (f2 === "Directive" || f2 === "TypeAlias" || f2 === "TSExportAssignment" || f2.startsWith("Declare") || f2.startsWith("TSDeclare") || f2.endsWith("Statement") || f2.endsWith("Declaration"));
                        }
                        var y = /* @__PURE__ */ new Set([
                            "ObjectExpression",
                            "ArrayExpression",
                            "StringLiteral",
                            "NumericLiteral",
                            "BooleanLiteral",
                            "NullLiteral",
                            "UnaryExpression",
                            "TemplateLiteral"
                        ]), h = /* @__PURE__ */ new Set([
                            "OperationDefinition",
                            "FragmentDefinition",
                            "VariableDefinition",
                            "TypeExtensionDefinition",
                            "ObjectTypeDefinition",
                            "FieldDefinition",
                            "DirectiveDefinition",
                            "EnumTypeDefinition",
                            "EnumValueDefinition",
                            "InputValueDefinition",
                            "InputObjectTypeDefinition",
                            "SchemaDefinition",
                            "OperationTypeDefinition",
                            "InterfaceTypeDefinition",
                            "UnionTypeDefinition",
                            "ScalarTypeDefinition"
                        ]);
                        function g(f2, F, _2) {
                            if (!F) return false;
                            switch(f2.parser){
                                case "flow":
                                case "babel":
                                case "babel-flow":
                                case "babel-ts":
                                case "typescript":
                                case "acorn":
                                case "espree":
                                case "meriyah":
                                case "__babel_estree":
                                    return p(F.type, _2 && _2.type);
                                case "json":
                                case "json5":
                                case "json-stringify":
                                    return y.has(F.type);
                                case "graphql":
                                    return h.has(F.kind);
                                case "vue":
                                    return F.tag !== "root";
                            }
                            return false;
                        }
                        function c(f2, F, _2) {
                            let { rangeStart: w, rangeEnd: E, locStart: N, locEnd: x } = F;
                            t1.ok(E > w);
                            let I = f2.slice(w, E).search(/\S/), P = I === -1;
                            if (!P) for(w += I; E > w && !/\S/.test(f2[E - 1]); --E);
                            let $ = l(_2, w, F, (C, o)=>g(F, C, o), [], "rangeStart"), D = P ? $ : l(_2, E, F, (C)=>g(F, C), [], "rangeEnd");
                            if (!$ || !D) return {
                                rangeStart: 0,
                                rangeEnd: 0
                            };
                            let T, m;
                            if (a2(F)) {
                                let C = n($, D);
                                T = C, m = C;
                            } else ({ startNode: T, endNode: m } = i($, D, F));
                            return {
                                rangeStart: Math.min(N(T), N(m)),
                                rangeEnd: Math.max(x(T), x(m))
                            };
                        }
                        r.exports = {
                            calculateRange: c,
                            findNodeAtOffset: l
                        };
                    }
                }), Gm = te({
                    "src/main/core.js" (e, r) {
                        "use strict";
                        ne();
                        var { diffArrays: t1 } = BD(), { printer: { printDocToString: s }, debug: { printDocToDebug: a2 } } = qe(), { getAlignmentSize: n } = Ue(), { guessEndOfLine: u, convertEndOfLineToChars: i, countEndOfLineChars: l, normalizeEndOfLine: p } = Jn(), y = uo().normalize, h = Rm(), g = et(), c = tu(), f2 = Wm(), F = Hm(), _2 = "\uFEFF", w = Symbol("cursor");
                        function E(m, C, o) {
                            let d = C.comments;
                            return d && (delete C.comments, g.attach(d, C, m, o)), o[Symbol.for("comments")] = d || [], o[Symbol.for("tokens")] = C.tokens || [], o.originalText = m, d;
                        }
                        function N(m, C) {
                            let o = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
                            if (!m || m.trim().length === 0) return {
                                formatted: "",
                                cursorOffset: -1,
                                comments: []
                            };
                            let { ast: d, text: v } = c.parse(m, C);
                            if (C.cursorOffset >= 0) {
                                let k = F.findNodeAtOffset(d, C.cursorOffset, C);
                                k && k.node && (C.cursorNode = k.node);
                            }
                            let S = E(v, d, C), b = f2(d, C, o), B = s(b, C);
                            if (g.ensureAllCommentsPrinted(S), o > 0) {
                                let k = B.formatted.trim();
                                B.cursorNodeStart !== void 0 && (B.cursorNodeStart -= B.formatted.indexOf(k)), B.formatted = k + i(C.endOfLine);
                            }
                            if (C.cursorOffset >= 0) {
                                let k, M, R, q, J;
                                if (C.cursorNode && B.cursorNodeText ? (k = C.locStart(C.cursorNode), M = v.slice(k, C.locEnd(C.cursorNode)), R = C.cursorOffset - k, q = B.cursorNodeStart, J = B.cursorNodeText) : (k = 0, M = v, R = C.cursorOffset, q = 0, J = B.formatted), M === J) return {
                                    formatted: B.formatted,
                                    cursorOffset: q + R,
                                    comments: S
                                };
                                let L = [
                                    ...M
                                ];
                                L.splice(R, 0, w);
                                let Q = [
                                    ...J
                                ], V = t1(L, Q), j = q;
                                for (let Y of V)if (Y.removed) {
                                    if (Y.value.includes(w)) break;
                                } else j += Y.count;
                                return {
                                    formatted: B.formatted,
                                    cursorOffset: j,
                                    comments: S
                                };
                            }
                            return {
                                formatted: B.formatted,
                                cursorOffset: -1,
                                comments: S
                            };
                        }
                        function x(m, C) {
                            let { ast: o, text: d } = c.parse(m, C), { rangeStart: v, rangeEnd: S } = F.calculateRange(d, C, o), b = d.slice(v, S), B = Math.min(v, d.lastIndexOf(`
`, v) + 1), k = d.slice(B, v).match(/^\s*/)[0], M = n(k, C.tabWidth), R = N(b, Object.assign(Object.assign({}, C), {}, {
                                rangeStart: 0,
                                rangeEnd: Number.POSITIVE_INFINITY,
                                cursorOffset: C.cursorOffset > v && C.cursorOffset <= S ? C.cursorOffset - v : -1,
                                endOfLine: "lf"
                            }), M), q = R.formatted.trimEnd(), { cursorOffset: J } = C;
                            J > S ? J += q.length - b.length : R.cursorOffset >= 0 && (J = R.cursorOffset + v);
                            let L = d.slice(0, v) + q + d.slice(S);
                            if (C.endOfLine !== "lf") {
                                let Q = i(C.endOfLine);
                                J >= 0 && Q === `\r
` && (J += l(L.slice(0, J), `
`)), L = L.replace(/\n/g, Q);
                            }
                            return {
                                formatted: L,
                                cursorOffset: J,
                                comments: R.comments
                            };
                        }
                        function I(m, C, o) {
                            return typeof C != "number" || Number.isNaN(C) || C < 0 || C > m.length ? o : C;
                        }
                        function P(m, C) {
                            let { cursorOffset: o, rangeStart: d, rangeEnd: v } = C;
                            return o = I(m, o, -1), d = I(m, d, 0), v = I(m, v, m.length), Object.assign(Object.assign({}, C), {}, {
                                cursorOffset: o,
                                rangeStart: d,
                                rangeEnd: v
                            });
                        }
                        function $(m, C) {
                            let { cursorOffset: o, rangeStart: d, rangeEnd: v, endOfLine: S } = P(m, C), b = m.charAt(0) === _2;
                            if (b && (m = m.slice(1), o--, d--, v--), S === "auto" && (S = u(m)), m.includes("\r")) {
                                let B = (k)=>l(m.slice(0, Math.max(k, 0)), `\r
`);
                                o -= B(o), d -= B(d), v -= B(v), m = p(m);
                            }
                            return {
                                hasBOM: b,
                                text: m,
                                options: P(m, Object.assign(Object.assign({}, C), {}, {
                                    cursorOffset: o,
                                    rangeStart: d,
                                    rangeEnd: v,
                                    endOfLine: S
                                }))
                            };
                        }
                        function D(m, C) {
                            let o = c.resolveParser(C);
                            return !o.hasPragma || o.hasPragma(m);
                        }
                        function T(m, C) {
                            let { hasBOM: o, text: d, options: v } = $(m, y(C));
                            if (v.rangeStart >= v.rangeEnd && d !== "" || v.requirePragma && !D(d, v)) return {
                                formatted: m,
                                cursorOffset: C.cursorOffset,
                                comments: []
                            };
                            let S;
                            return v.rangeStart > 0 || v.rangeEnd < d.length ? S = x(d, v) : (!v.requirePragma && v.insertPragma && v.printer.insertPragma && !D(d, v) && (d = v.printer.insertPragma(d)), S = N(d, v)), o && (S.formatted = _2 + S.formatted, S.cursorOffset >= 0 && S.cursorOffset++), S;
                        }
                        r.exports = {
                            formatWithCursor: T,
                            parse (m, C, o) {
                                let { text: d, options: v } = $(m, y(C)), S = c.parse(d, v);
                                return o && (S.ast = h(S.ast, v)), S;
                            },
                            formatAST (m, C) {
                                C = y(C);
                                let o = f2(m, C);
                                return s(o, C);
                            },
                            formatDoc (m, C) {
                                return T(a2(m), Object.assign(Object.assign({}, C), {}, {
                                    parser: "__js_expression"
                                })).formatted;
                            },
                            printToDoc (m, C) {
                                C = y(C);
                                let { ast: o, text: d } = c.parse(m, C);
                                return E(d, o, C), f2(o, C);
                            },
                            printDocToString (m, C) {
                                return s(m, y(C));
                            }
                        };
                    }
                }), Um = te({
                    "src/common/util-shared.js" (e, r) {
                        "use strict";
                        ne();
                        var { getMaxContinuousCount: t1, getStringWidth: s, getAlignmentSize: a2, getIndentSize: n, skip: u, skipWhitespace: i, skipSpaces: l, skipNewline: p, skipToLineEnd: y, skipEverythingButNewLine: h, skipInlineComment: g, skipTrailingComment: c, hasNewline: f2, hasNewlineInRange: F, hasSpaces: _2, isNextLineEmpty: w, isNextLineEmptyAfterIndex: E, isPreviousLineEmpty: N, getNextNonSpaceNonCommentCharacterIndex: x, makeString: I, addLeadingComment: P, addDanglingComment: $, addTrailingComment: D } = Ue();
                        r.exports = {
                            getMaxContinuousCount: t1,
                            getStringWidth: s,
                            getAlignmentSize: a2,
                            getIndentSize: n,
                            skip: u,
                            skipWhitespace: i,
                            skipSpaces: l,
                            skipNewline: p,
                            skipToLineEnd: y,
                            skipEverythingButNewLine: h,
                            skipInlineComment: g,
                            skipTrailingComment: c,
                            hasNewline: f2,
                            hasNewlineInRange: F,
                            hasSpaces: _2,
                            isNextLineEmpty: w,
                            isNextLineEmptyAfterIndex: E,
                            isPreviousLineEmpty: N,
                            getNextNonSpaceNonCommentCharacterIndex: x,
                            makeString: I,
                            addLeadingComment: P,
                            addDanglingComment: $,
                            addTrailingComment: D
                        };
                    }
                }), _t = te({
                    "src/utils/create-language.js" (e, r) {
                        "use strict";
                        ne(), r.exports = function(t1, s) {
                            let { languageId: a2 } = t1, n = Hn(t1, CD);
                            return Object.assign(Object.assign({
                                linguistLanguageId: a2
                            }, n), s(t1));
                        };
                    }
                }), Jm = te({
                    "node_modules/esutils/lib/ast.js" (e, r) {
                        ne(), function() {
                            "use strict";
                            function t1(l) {
                                if (l == null) return false;
                                switch(l.type){
                                    case "ArrayExpression":
                                    case "AssignmentExpression":
                                    case "BinaryExpression":
                                    case "CallExpression":
                                    case "ConditionalExpression":
                                    case "FunctionExpression":
                                    case "Identifier":
                                    case "Literal":
                                    case "LogicalExpression":
                                    case "MemberExpression":
                                    case "NewExpression":
                                    case "ObjectExpression":
                                    case "SequenceExpression":
                                    case "ThisExpression":
                                    case "UnaryExpression":
                                    case "UpdateExpression":
                                        return true;
                                }
                                return false;
                            }
                            function s(l) {
                                if (l == null) return false;
                                switch(l.type){
                                    case "DoWhileStatement":
                                    case "ForInStatement":
                                    case "ForStatement":
                                    case "WhileStatement":
                                        return true;
                                }
                                return false;
                            }
                            function a2(l) {
                                if (l == null) return false;
                                switch(l.type){
                                    case "BlockStatement":
                                    case "BreakStatement":
                                    case "ContinueStatement":
                                    case "DebuggerStatement":
                                    case "DoWhileStatement":
                                    case "EmptyStatement":
                                    case "ExpressionStatement":
                                    case "ForInStatement":
                                    case "ForStatement":
                                    case "IfStatement":
                                    case "LabeledStatement":
                                    case "ReturnStatement":
                                    case "SwitchStatement":
                                    case "ThrowStatement":
                                    case "TryStatement":
                                    case "VariableDeclaration":
                                    case "WhileStatement":
                                    case "WithStatement":
                                        return true;
                                }
                                return false;
                            }
                            function n(l) {
                                return a2(l) || l != null && l.type === "FunctionDeclaration";
                            }
                            function u(l) {
                                switch(l.type){
                                    case "IfStatement":
                                        return l.alternate != null ? l.alternate : l.consequent;
                                    case "LabeledStatement":
                                    case "ForStatement":
                                    case "ForInStatement":
                                    case "WhileStatement":
                                    case "WithStatement":
                                        return l.body;
                                }
                                return null;
                            }
                            function i(l) {
                                var p;
                                if (l.type !== "IfStatement" || l.alternate == null) return false;
                                p = l.consequent;
                                do {
                                    if (p.type === "IfStatement" && p.alternate == null) return true;
                                    p = u(p);
                                }while (p)
                                return false;
                            }
                            r.exports = {
                                isExpression: t1,
                                isStatement: a2,
                                isIterationStatement: s,
                                isSourceElement: n,
                                isProblematicIfStatement: i,
                                trailingStatement: u
                            };
                        }();
                    }
                }), so = te({
                    "node_modules/esutils/lib/code.js" (e, r) {
                        ne(), function() {
                            "use strict";
                            var t1, s, a2, n, u, i;
                            s = {
                                NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/,
                                NonAsciiIdentifierPart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/
                            }, t1 = {
                                NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/,
                                NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/
                            };
                            function l(E) {
                                return 48 <= E && E <= 57;
                            }
                            function p(E) {
                                return 48 <= E && E <= 57 || 97 <= E && E <= 102 || 65 <= E && E <= 70;
                            }
                            function y(E) {
                                return E >= 48 && E <= 55;
                            }
                            a2 = [
                                5760,
                                8192,
                                8193,
                                8194,
                                8195,
                                8196,
                                8197,
                                8198,
                                8199,
                                8200,
                                8201,
                                8202,
                                8239,
                                8287,
                                12288,
                                65279
                            ];
                            function h(E) {
                                return E === 32 || E === 9 || E === 11 || E === 12 || E === 160 || E >= 5760 && a2.indexOf(E) >= 0;
                            }
                            function g(E) {
                                return E === 10 || E === 13 || E === 8232 || E === 8233;
                            }
                            function c(E) {
                                if (E <= 65535) return String.fromCharCode(E);
                                var N = String.fromCharCode(Math.floor((E - 65536) / 1024) + 55296), x = String.fromCharCode((E - 65536) % 1024 + 56320);
                                return N + x;
                            }
                            for(n = new Array(128), i = 0; i < 128; ++i)n[i] = i >= 97 && i <= 122 || i >= 65 && i <= 90 || i === 36 || i === 95;
                            for(u = new Array(128), i = 0; i < 128; ++i)u[i] = i >= 97 && i <= 122 || i >= 65 && i <= 90 || i >= 48 && i <= 57 || i === 36 || i === 95;
                            function f2(E) {
                                return E < 128 ? n[E] : s.NonAsciiIdentifierStart.test(c(E));
                            }
                            function F(E) {
                                return E < 128 ? u[E] : s.NonAsciiIdentifierPart.test(c(E));
                            }
                            function _2(E) {
                                return E < 128 ? n[E] : t1.NonAsciiIdentifierStart.test(c(E));
                            }
                            function w(E) {
                                return E < 128 ? u[E] : t1.NonAsciiIdentifierPart.test(c(E));
                            }
                            r.exports = {
                                isDecimalDigit: l,
                                isHexDigit: p,
                                isOctalDigit: y,
                                isWhiteSpace: h,
                                isLineTerminator: g,
                                isIdentifierStartES5: f2,
                                isIdentifierPartES5: F,
                                isIdentifierStartES6: _2,
                                isIdentifierPartES6: w
                            };
                        }();
                    }
                }), zm = te({
                    "node_modules/esutils/lib/keyword.js" (e, r) {
                        ne(), function() {
                            "use strict";
                            var t1 = so();
                            function s(f2) {
                                switch(f2){
                                    case "implements":
                                    case "interface":
                                    case "package":
                                    case "private":
                                    case "protected":
                                    case "public":
                                    case "static":
                                    case "let":
                                        return true;
                                    default:
                                        return false;
                                }
                            }
                            function a2(f2, F) {
                                return !F && f2 === "yield" ? false : n(f2, F);
                            }
                            function n(f2, F) {
                                if (F && s(f2)) return true;
                                switch(f2.length){
                                    case 2:
                                        return f2 === "if" || f2 === "in" || f2 === "do";
                                    case 3:
                                        return f2 === "var" || f2 === "for" || f2 === "new" || f2 === "try";
                                    case 4:
                                        return f2 === "this" || f2 === "else" || f2 === "case" || f2 === "void" || f2 === "with" || f2 === "enum";
                                    case 5:
                                        return f2 === "while" || f2 === "break" || f2 === "catch" || f2 === "throw" || f2 === "const" || f2 === "yield" || f2 === "class" || f2 === "super";
                                    case 6:
                                        return f2 === "return" || f2 === "typeof" || f2 === "delete" || f2 === "switch" || f2 === "export" || f2 === "import";
                                    case 7:
                                        return f2 === "default" || f2 === "finally" || f2 === "extends";
                                    case 8:
                                        return f2 === "function" || f2 === "continue" || f2 === "debugger";
                                    case 10:
                                        return f2 === "instanceof";
                                    default:
                                        return false;
                                }
                            }
                            function u(f2, F) {
                                return f2 === "null" || f2 === "true" || f2 === "false" || a2(f2, F);
                            }
                            function i(f2, F) {
                                return f2 === "null" || f2 === "true" || f2 === "false" || n(f2, F);
                            }
                            function l(f2) {
                                return f2 === "eval" || f2 === "arguments";
                            }
                            function p(f2) {
                                var F, _2, w;
                                if (f2.length === 0 || (w = f2.charCodeAt(0), !t1.isIdentifierStartES5(w))) return false;
                                for(F = 1, _2 = f2.length; F < _2; ++F)if (w = f2.charCodeAt(F), !t1.isIdentifierPartES5(w)) return false;
                                return true;
                            }
                            function y(f2, F) {
                                return (f2 - 55296) * 1024 + (F - 56320) + 65536;
                            }
                            function h(f2) {
                                var F, _2, w, E, N;
                                if (f2.length === 0) return false;
                                for(N = t1.isIdentifierStartES6, F = 0, _2 = f2.length; F < _2; ++F){
                                    if (w = f2.charCodeAt(F), 55296 <= w && w <= 56319) {
                                        if (++F, F >= _2 || (E = f2.charCodeAt(F), !(56320 <= E && E <= 57343))) return false;
                                        w = y(w, E);
                                    }
                                    if (!N(w)) return false;
                                    N = t1.isIdentifierPartES6;
                                }
                                return true;
                            }
                            function g(f2, F) {
                                return p(f2) && !u(f2, F);
                            }
                            function c(f2, F) {
                                return h(f2) && !i(f2, F);
                            }
                            r.exports = {
                                isKeywordES5: a2,
                                isKeywordES6: n,
                                isReservedWordES5: u,
                                isReservedWordES6: i,
                                isRestrictedWord: l,
                                isIdentifierNameES5: p,
                                isIdentifierNameES6: h,
                                isIdentifierES5: g,
                                isIdentifierES6: c
                            };
                        }();
                    }
                }), Xm = te({
                    "node_modules/esutils/lib/utils.js" (e) {
                        ne(), function() {
                            "use strict";
                            e.ast = Jm(), e.code = so(), e.keyword = zm();
                        }();
                    }
                }), Pt = te({
                    "src/language-js/utils/is-block-comment.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = /* @__PURE__ */ new Set([
                            "Block",
                            "CommentBlock",
                            "MultiLine"
                        ]), s = (a2)=>t1.has(a2 == null ? void 0 : a2.type);
                        r.exports = s;
                    }
                }), Km = te({
                    "src/language-js/utils/is-node-matches.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(a2, n) {
                            let u = n.split(".");
                            for(let i = u.length - 1; i >= 0; i--){
                                let l = u[i];
                                if (i === 0) return a2.type === "Identifier" && a2.name === l;
                                if (a2.type !== "MemberExpression" || a2.optional || a2.computed || a2.property.type !== "Identifier" || a2.property.name !== l) return false;
                                a2 = a2.object;
                            }
                        }
                        function s(a2, n) {
                            return n.some((u)=>t1(a2, u));
                        }
                        r.exports = s;
                    }
                }), Ke = te({
                    "src/language-js/utils/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Xm().keyword.isIdentifierNameES5, { getLast: s, hasNewline: a2, skipWhitespace: n, isNonEmptyArray: u, isNextLineEmptyAfterIndex: i, getStringWidth: l } = Ue(), { locStart: p, locEnd: y, hasSameLocStart: h } = ut(), g = Pt(), c = Km(), f2 = "(?:(?=.)\\s)", F = new RegExp(`^${f2}*:`), _2 = new RegExp(`^${f2}*::`);
                        function w(O) {
                            var me, _e;
                            return ((me = O.extra) === null || me === void 0 ? void 0 : me.parenthesized) && g((_e = O.trailingComments) === null || _e === void 0 ? void 0 : _e[0]) && F.test(O.trailingComments[0].value);
                        }
                        function E(O) {
                            let me = O == null ? void 0 : O[0];
                            return g(me) && _2.test(me.value);
                        }
                        function N(O, me) {
                            if (!O || typeof O != "object") return false;
                            if (Array.isArray(O)) return O.some((He)=>N(He, me));
                            let _e = me(O);
                            return typeof _e == "boolean" ? _e : Object.values(O).some((He)=>N(He, me));
                        }
                        function x(O) {
                            return O.type === "AssignmentExpression" || O.type === "BinaryExpression" || O.type === "LogicalExpression" || O.type === "NGPipeExpression" || O.type === "ConditionalExpression" || de(O) || ue(O) || O.type === "SequenceExpression" || O.type === "TaggedTemplateExpression" || O.type === "BindExpression" || O.type === "UpdateExpression" && !O.prefix || st(O) || O.type === "TSNonNullExpression";
                        }
                        function I(O) {
                            var me, _e, He, Ge, it, Qe;
                            return O.expressions ? O.expressions[0] : (me = (_e = (He = (Ge = (it = (Qe = O.left) !== null && Qe !== void 0 ? Qe : O.test) !== null && it !== void 0 ? it : O.callee) !== null && Ge !== void 0 ? Ge : O.object) !== null && He !== void 0 ? He : O.tag) !== null && _e !== void 0 ? _e : O.argument) !== null && me !== void 0 ? me : O.expression;
                        }
                        function P(O, me) {
                            if (me.expressions) return [
                                "expressions",
                                0
                            ];
                            if (me.left) return [
                                "left"
                            ];
                            if (me.test) return [
                                "test"
                            ];
                            if (me.object) return [
                                "object"
                            ];
                            if (me.callee) return [
                                "callee"
                            ];
                            if (me.tag) return [
                                "tag"
                            ];
                            if (me.argument) return [
                                "argument"
                            ];
                            if (me.expression) return [
                                "expression"
                            ];
                            throw new Error("Unexpected node has no left side.");
                        }
                        function $(O) {
                            return O = new Set(O), (me)=>O.has(me == null ? void 0 : me.type);
                        }
                        var D = $([
                            "Line",
                            "CommentLine",
                            "SingleLine",
                            "HashbangComment",
                            "HTMLOpen",
                            "HTMLClose"
                        ]), T = $([
                            "ExportDefaultDeclaration",
                            "ExportDefaultSpecifier",
                            "DeclareExportDeclaration",
                            "ExportNamedDeclaration",
                            "ExportAllDeclaration"
                        ]);
                        function m(O) {
                            let me = O.getParentNode();
                            return O.getName() === "declaration" && T(me) ? me : null;
                        }
                        var C = $([
                            "BooleanLiteral",
                            "DirectiveLiteral",
                            "Literal",
                            "NullLiteral",
                            "NumericLiteral",
                            "BigIntLiteral",
                            "DecimalLiteral",
                            "RegExpLiteral",
                            "StringLiteral",
                            "TemplateLiteral",
                            "TSTypeLiteral",
                            "JSXText"
                        ]);
                        function o(O) {
                            return O.type === "NumericLiteral" || O.type === "Literal" && typeof O.value == "number";
                        }
                        function d(O) {
                            return O.type === "UnaryExpression" && (O.operator === "+" || O.operator === "-") && o(O.argument);
                        }
                        function v(O) {
                            return O.type === "StringLiteral" || O.type === "Literal" && typeof O.value == "string";
                        }
                        var S = $([
                            "ObjectTypeAnnotation",
                            "TSTypeLiteral",
                            "TSMappedType"
                        ]), b = $([
                            "FunctionExpression",
                            "ArrowFunctionExpression"
                        ]);
                        function B(O) {
                            return O.type === "FunctionExpression" || O.type === "ArrowFunctionExpression" && O.body.type === "BlockStatement";
                        }
                        function k(O) {
                            return de(O) && O.callee.type === "Identifier" && [
                                "async",
                                "inject",
                                "fakeAsync",
                                "waitForAsync"
                            ].includes(O.callee.name);
                        }
                        var M = $([
                            "JSXElement",
                            "JSXFragment"
                        ]);
                        function R(O, me) {
                            if (O.parentParser !== "markdown" && O.parentParser !== "mdx") return false;
                            let _e = me.getNode();
                            if (!_e.expression || !M(_e.expression)) return false;
                            let He = me.getParentNode();
                            return He.type === "Program" && He.body.length === 1;
                        }
                        function q(O) {
                            return O.kind === "get" || O.kind === "set";
                        }
                        function J(O) {
                            return q(O) || h(O, O.value);
                        }
                        function L(O) {
                            return (O.type === "ObjectTypeProperty" || O.type === "ObjectTypeInternalSlot") && O.value.type === "FunctionTypeAnnotation" && !O.static && !J(O);
                        }
                        function Q(O) {
                            return (O.type === "TypeAnnotation" || O.type === "TSTypeAnnotation") && O.typeAnnotation.type === "FunctionTypeAnnotation" && !O.static && !h(O, O.typeAnnotation);
                        }
                        var V = $([
                            "BinaryExpression",
                            "LogicalExpression",
                            "NGPipeExpression"
                        ]);
                        function j(O) {
                            return ue(O) || O.type === "BindExpression" && Boolean(O.object);
                        }
                        var Y = /* @__PURE__ */ new Set([
                            "AnyTypeAnnotation",
                            "TSAnyKeyword",
                            "NullLiteralTypeAnnotation",
                            "TSNullKeyword",
                            "ThisTypeAnnotation",
                            "TSThisType",
                            "NumberTypeAnnotation",
                            "TSNumberKeyword",
                            "VoidTypeAnnotation",
                            "TSVoidKeyword",
                            "BooleanTypeAnnotation",
                            "TSBooleanKeyword",
                            "BigIntTypeAnnotation",
                            "TSBigIntKeyword",
                            "SymbolTypeAnnotation",
                            "TSSymbolKeyword",
                            "StringTypeAnnotation",
                            "TSStringKeyword",
                            "BooleanLiteralTypeAnnotation",
                            "StringLiteralTypeAnnotation",
                            "BigIntLiteralTypeAnnotation",
                            "NumberLiteralTypeAnnotation",
                            "TSLiteralType",
                            "TSTemplateLiteralType",
                            "EmptyTypeAnnotation",
                            "MixedTypeAnnotation",
                            "TSNeverKeyword",
                            "TSObjectKeyword",
                            "TSUndefinedKeyword",
                            "TSUnknownKeyword"
                        ]);
                        function ie(O) {
                            return O ? !!((O.type === "GenericTypeAnnotation" || O.type === "TSTypeReference") && !O.typeParameters || Y.has(O.type)) : false;
                        }
                        function ee(O) {
                            let me = /^(?:before|after)(?:Each|All)$/;
                            return O.callee.type === "Identifier" && me.test(O.callee.name) && O.arguments.length === 1;
                        }
                        var ce = [
                            "it",
                            "it.only",
                            "it.skip",
                            "describe",
                            "describe.only",
                            "describe.skip",
                            "test",
                            "test.only",
                            "test.skip",
                            "test.step",
                            "test.describe",
                            "test.describe.only",
                            "test.describe.parallel",
                            "test.describe.parallel.only",
                            "test.describe.serial",
                            "test.describe.serial.only",
                            "skip",
                            "xit",
                            "xdescribe",
                            "xtest",
                            "fit",
                            "fdescribe",
                            "ftest"
                        ];
                        function W(O) {
                            return c(O, ce);
                        }
                        function K(O, me) {
                            if (O.type !== "CallExpression") return false;
                            if (O.arguments.length === 1) {
                                if (k(O) && me && K(me)) return b(O.arguments[0]);
                                if (ee(O)) return k(O.arguments[0]);
                            } else if ((O.arguments.length === 2 || O.arguments.length === 3) && (O.arguments[0].type === "TemplateLiteral" || v(O.arguments[0])) && W(O.callee)) return O.arguments[2] && !o(O.arguments[2]) ? false : (O.arguments.length === 2 ? b(O.arguments[1]) : B(O.arguments[1]) && ve(O.arguments[1]).length <= 1) || k(O.arguments[1]);
                            return false;
                        }
                        var de = $([
                            "CallExpression",
                            "OptionalCallExpression"
                        ]), ue = $([
                            "MemberExpression",
                            "OptionalMemberExpression"
                        ]);
                        function Fe(O) {
                            let me = "expressions";
                            O.type === "TSTemplateLiteralType" && (me = "types");
                            let _e = O[me];
                            return _e.length === 0 ? false : _e.every((He)=>{
                                if (Me(He)) return false;
                                if (He.type === "Identifier" || He.type === "ThisExpression") return true;
                                if (ue(He)) {
                                    let Ge = He;
                                    for(; ue(Ge);)if (Ge.property.type !== "Identifier" && Ge.property.type !== "Literal" && Ge.property.type !== "StringLiteral" && Ge.property.type !== "NumericLiteral" || (Ge = Ge.object, Me(Ge))) return false;
                                    return Ge.type === "Identifier" || Ge.type === "ThisExpression";
                                }
                                return false;
                            });
                        }
                        function z(O, me) {
                            return O === "+" || O === "-" ? O + me : me;
                        }
                        function U(O, me) {
                            let _e = p(me), He = n(O, y(me));
                            return He !== false && O.slice(_e, _e + 2) === "/*" && O.slice(He, He + 2) === "*/";
                        }
                        function Z(O, me) {
                            return M(me) ? Oe(me) : Me(me, Te.Leading, (_e)=>a2(O, y(_e)));
                        }
                        function se(O, me) {
                            return me.parser !== "json" && v(O.key) && oe(O.key).slice(1, -1) === O.key.value && (t1(O.key.value) && !(me.parser === "babel-ts" && O.type === "ClassProperty" || me.parser === "typescript" && O.type === "PropertyDefinition") || fe(O.key.value) && String(Number(O.key.value)) === O.key.value && (me.parser === "babel" || me.parser === "acorn" || me.parser === "espree" || me.parser === "meriyah" || me.parser === "__babel_estree"));
                        }
                        function fe(O) {
                            return /^(?:\d+|\d+\.\d+)$/.test(O);
                        }
                        function ge(O, me) {
                            let _e = /^[fx]?(?:describe|it|test)$/;
                            return me.type === "TaggedTemplateExpression" && me.quasi === O && me.tag.type === "MemberExpression" && me.tag.property.type === "Identifier" && me.tag.property.name === "each" && (me.tag.object.type === "Identifier" && _e.test(me.tag.object.name) || me.tag.object.type === "MemberExpression" && me.tag.object.property.type === "Identifier" && (me.tag.object.property.name === "only" || me.tag.object.property.name === "skip") && me.tag.object.object.type === "Identifier" && _e.test(me.tag.object.object.name));
                        }
                        function he(O) {
                            return O.quasis.some((me)=>me.value.raw.includes(`
`));
                        }
                        function we(O, me) {
                            return (O.type === "TemplateLiteral" && he(O) || O.type === "TaggedTemplateExpression" && he(O.quasi)) && !a2(me, p(O), {
                                backwards: true
                            });
                        }
                        function ke(O) {
                            if (!Me(O)) return false;
                            let me = s(ae(O, Te.Dangling));
                            return me && !g(me);
                        }
                        function Re(O) {
                            if (O.length <= 1) return false;
                            let me = 0;
                            for (let _e of O)if (b(_e)) {
                                if (me += 1, me > 1) return true;
                            } else if (de(_e)) {
                                for (let He of _e.arguments)if (b(He)) return true;
                            }
                            return false;
                        }
                        function Ne(O) {
                            let me = O.getValue(), _e = O.getParentNode();
                            return de(me) && de(_e) && _e.callee === me && me.arguments.length > _e.arguments.length && _e.arguments.length > 0;
                        }
                        function Pe(O, me) {
                            if (me >= 2) return false;
                            let _e = (Qe)=>Pe(Qe, me + 1), He = O.type === "Literal" && "regex" in O && O.regex.pattern || O.type === "RegExpLiteral" && O.pattern;
                            if (He && l(He) > 5) return false;
                            if (O.type === "Literal" || O.type === "BigIntLiteral" || O.type === "DecimalLiteral" || O.type === "BooleanLiteral" || O.type === "NullLiteral" || O.type === "NumericLiteral" || O.type === "RegExpLiteral" || O.type === "StringLiteral" || O.type === "Identifier" || O.type === "ThisExpression" || O.type === "Super" || O.type === "PrivateName" || O.type === "PrivateIdentifier" || O.type === "ArgumentPlaceholder" || O.type === "Import") return true;
                            if (O.type === "TemplateLiteral") return O.quasis.every((Qe)=>!Qe.value.raw.includes(`
`)) && O.expressions.every(_e);
                            if (O.type === "ObjectExpression") return O.properties.every((Qe)=>!Qe.computed && (Qe.shorthand || Qe.value && _e(Qe.value)));
                            if (O.type === "ArrayExpression") return O.elements.every((Qe)=>Qe === null || _e(Qe));
                            if (tt(O)) return (O.type === "ImportExpression" || Pe(O.callee, me)) && Ye(O).every(_e);
                            if (ue(O)) return Pe(O.object, me) && Pe(O.property, me);
                            let Ge = {
                                "!": true,
                                "-": true,
                                "+": true,
                                "~": true
                            };
                            if (O.type === "UnaryExpression" && Ge[O.operator]) return Pe(O.argument, me);
                            let it = {
                                "++": true,
                                "--": true
                            };
                            return O.type === "UpdateExpression" && it[O.operator] ? Pe(O.argument, me) : O.type === "TSNonNullExpression" ? Pe(O.expression, me) : false;
                        }
                        function oe(O) {
                            var me, _e;
                            return (me = (_e = O.extra) === null || _e === void 0 ? void 0 : _e.raw) !== null && me !== void 0 ? me : O.raw;
                        }
                        function H(O) {
                            return O;
                        }
                        function pe(O) {
                            return O.filepath && /\.tsx$/i.test(O.filepath);
                        }
                        function X(O) {
                            let me = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "es5";
                            return O.trailingComma === "es5" && me === "es5" || O.trailingComma === "all" && (me === "all" || me === "es5");
                        }
                        function le(O, me) {
                            switch(O.type){
                                case "BinaryExpression":
                                case "LogicalExpression":
                                case "AssignmentExpression":
                                case "NGPipeExpression":
                                    return le(O.left, me);
                                case "MemberExpression":
                                case "OptionalMemberExpression":
                                    return le(O.object, me);
                                case "TaggedTemplateExpression":
                                    return O.tag.type === "FunctionExpression" ? false : le(O.tag, me);
                                case "CallExpression":
                                case "OptionalCallExpression":
                                    return O.callee.type === "FunctionExpression" ? false : le(O.callee, me);
                                case "ConditionalExpression":
                                    return le(O.test, me);
                                case "UpdateExpression":
                                    return !O.prefix && le(O.argument, me);
                                case "BindExpression":
                                    return O.object && le(O.object, me);
                                case "SequenceExpression":
                                    return le(O.expressions[0], me);
                                case "TSSatisfiesExpression":
                                case "TSAsExpression":
                                case "TSNonNullExpression":
                                    return le(O.expression, me);
                                default:
                                    return me(O);
                            }
                        }
                        var Ae = {
                            "==": true,
                            "!=": true,
                            "===": true,
                            "!==": true
                        }, Ee = {
                            "*": true,
                            "/": true,
                            "%": true
                        }, De = {
                            ">>": true,
                            ">>>": true,
                            "<<": true
                        };
                        function A2(O, me) {
                            return !(re(me) !== re(O) || O === "**" || Ae[O] && Ae[me] || me === "%" && Ee[O] || O === "%" && Ee[me] || me !== O && Ee[me] && Ee[O] || De[O] && De[me]);
                        }
                        var G = new Map([
                            [
                                "|>"
                            ],
                            [
                                "??"
                            ],
                            [
                                "||"
                            ],
                            [
                                "&&"
                            ],
                            [
                                "|"
                            ],
                            [
                                "^"
                            ],
                            [
                                "&"
                            ],
                            [
                                "==",
                                "===",
                                "!=",
                                "!=="
                            ],
                            [
                                "<",
                                ">",
                                "<=",
                                ">=",
                                "in",
                                "instanceof"
                            ],
                            [
                                ">>",
                                "<<",
                                ">>>"
                            ],
                            [
                                "+",
                                "-"
                            ],
                            [
                                "*",
                                "/",
                                "%"
                            ],
                            [
                                "**"
                            ]
                        ].flatMap((O, me)=>O.map((_e)=>[
                                    _e,
                                    me
                                ])));
                        function re(O) {
                            return G.get(O);
                        }
                        function ye(O) {
                            return Boolean(De[O]) || O === "|" || O === "^" || O === "&";
                        }
                        function Ce(O) {
                            var me;
                            if (O.rest) return true;
                            let _e = ve(O);
                            return ((me = s(_e)) === null || me === void 0 ? void 0 : me.type) === "RestElement";
                        }
                        var Be = /* @__PURE__ */ new WeakMap();
                        function ve(O) {
                            if (Be.has(O)) return Be.get(O);
                            let me = [];
                            return O.this && me.push(O.this), Array.isArray(O.parameters) ? me.push(...O.parameters) : Array.isArray(O.params) && me.push(...O.params), O.rest && me.push(O.rest), Be.set(O, me), me;
                        }
                        function ze(O, me) {
                            let _e = O.getValue(), He = 0, Ge = (it)=>me(it, He++);
                            _e.this && O.call(Ge, "this"), Array.isArray(_e.parameters) ? O.each(Ge, "parameters") : Array.isArray(_e.params) && O.each(Ge, "params"), _e.rest && O.call(Ge, "rest");
                        }
                        var be = /* @__PURE__ */ new WeakMap();
                        function Ye(O) {
                            if (be.has(O)) return be.get(O);
                            let me = O.arguments;
                            return O.type === "ImportExpression" && (me = [
                                O.source
                            ], O.attributes && me.push(O.attributes)), be.set(O, me), me;
                        }
                        function Se(O, me) {
                            let _e = O.getValue();
                            _e.type === "ImportExpression" ? (O.call((He)=>me(He, 0), "source"), _e.attributes && O.call((He)=>me(He, 1), "attributes")) : O.each(me, "arguments");
                        }
                        function Ie(O) {
                            return O.value.trim() === "prettier-ignore" && !O.unignore;
                        }
                        function Oe(O) {
                            return O && (O.prettierIgnore || Me(O, Te.PrettierIgnore));
                        }
                        function Je(O) {
                            let me = O.getValue();
                            return Oe(me);
                        }
                        var Te = {
                            Leading: 1 << 1,
                            Trailing: 1 << 2,
                            Dangling: 1 << 3,
                            Block: 1 << 4,
                            Line: 1 << 5,
                            PrettierIgnore: 1 << 6,
                            First: 1 << 7,
                            Last: 1 << 8
                        }, je = (O, me)=>{
                            if (typeof O == "function" && (me = O, O = 0), O || me) return (_e, He, Ge)=>!(O & Te.Leading && !_e.leading || O & Te.Trailing && !_e.trailing || O & Te.Dangling && (_e.leading || _e.trailing) || O & Te.Block && !g(_e) || O & Te.Line && !D(_e) || O & Te.First && He !== 0 || O & Te.Last && He !== Ge.length - 1 || O & Te.PrettierIgnore && !Ie(_e) || me && !me(_e));
                        };
                        function Me(O, me, _e) {
                            if (!u(O == null ? void 0 : O.comments)) return false;
                            let He = je(me, _e);
                            return He ? O.comments.some(He) : true;
                        }
                        function ae(O, me, _e) {
                            if (!Array.isArray(O == null ? void 0 : O.comments)) return [];
                            let He = je(me, _e);
                            return He ? O.comments.filter(He) : O.comments;
                        }
                        var nt = (O, me)=>{
                            let { originalText: _e } = me;
                            return i(_e, y(O));
                        };
                        function tt(O) {
                            return de(O) || O.type === "NewExpression" || O.type === "ImportExpression";
                        }
                        function Ve(O) {
                            return O && (O.type === "ObjectProperty" || O.type === "Property" && !O.method && O.kind === "init");
                        }
                        function We(O) {
                            return Boolean(O.__isUsingHackPipeline);
                        }
                        var Xe = Symbol("ifWithoutBlockAndSameLineComment");
                        function st(O) {
                            return O.type === "TSAsExpression" || O.type === "TSSatisfiesExpression";
                        }
                        r.exports = {
                            getFunctionParameters: ve,
                            iterateFunctionParametersPath: ze,
                            getCallArguments: Ye,
                            iterateCallArgumentsPath: Se,
                            hasRestParameter: Ce,
                            getLeftSide: I,
                            getLeftSidePathName: P,
                            getParentExportDeclaration: m,
                            getTypeScriptMappedTypeModifier: z,
                            hasFlowAnnotationComment: E,
                            hasFlowShorthandAnnotationComment: w,
                            hasLeadingOwnLineComment: Z,
                            hasNakedLeftSide: x,
                            hasNode: N,
                            hasIgnoreComment: Je,
                            hasNodeIgnoreComment: Oe,
                            identity: H,
                            isBinaryish: V,
                            isCallLikeExpression: tt,
                            isEnabledHackPipeline: We,
                            isLineComment: D,
                            isPrettierIgnoreComment: Ie,
                            isCallExpression: de,
                            isMemberExpression: ue,
                            isExportDeclaration: T,
                            isFlowAnnotationComment: U,
                            isFunctionCompositionArgs: Re,
                            isFunctionNotation: J,
                            isFunctionOrArrowExpression: b,
                            isGetterOrSetter: q,
                            isJestEachTemplateLiteral: ge,
                            isJsxNode: M,
                            isLiteral: C,
                            isLongCurriedCallExpression: Ne,
                            isSimpleCallArgument: Pe,
                            isMemberish: j,
                            isNumericLiteral: o,
                            isSignedNumericLiteral: d,
                            isObjectProperty: Ve,
                            isObjectType: S,
                            isObjectTypePropertyAFunction: L,
                            isSimpleType: ie,
                            isSimpleNumber: fe,
                            isSimpleTemplateLiteral: Fe,
                            isStringLiteral: v,
                            isStringPropSafeToUnquote: se,
                            isTemplateOnItsOwnLine: we,
                            isTestCall: K,
                            isTheOnlyJsxElementInMarkdown: R,
                            isTSXFile: pe,
                            isTypeAnnotationAFunction: Q,
                            isNextLineEmpty: nt,
                            needsHardlineAfterDanglingComment: ke,
                            rawText: oe,
                            shouldPrintComma: X,
                            isBitwiseOperator: ye,
                            shouldFlatten: A2,
                            startsWithNoLookaheadToken: le,
                            getPrecedence: re,
                            hasComment: Me,
                            getComments: ae,
                            CommentCheckFlags: Te,
                            markerForIfWithoutBlockAndSameLineComment: Xe,
                            isTSTypeExpression: st
                        };
                    }
                }), jt = te({
                    "src/language-js/print/template-literal.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = lt(), { getStringWidth: s, getIndentSize: a2 } = Ue(), { builders: { join: n, hardline: u, softline: i, group: l, indent: p, align: y, lineSuffixBoundary: h, addAlignmentToDoc: g }, printer: { printDocToString: c }, utils: { mapDoc: f2 } } = qe(), { isBinaryish: F, isJestEachTemplateLiteral: _2, isSimpleTemplateLiteral: w, hasComment: E, isMemberExpression: N, isTSTypeExpression: x } = Ke();
                        function I(C, o, d) {
                            let v = C.getValue();
                            if (v.type === "TemplateLiteral" && _2(v, C.getParentNode())) {
                                let R = P(C, d, o);
                                if (R) return R;
                            }
                            let b = "expressions";
                            v.type === "TSTemplateLiteralType" && (b = "types");
                            let B = [], k = C.map(o, b), M = w(v);
                            return M && (k = k.map((R)=>c(R, Object.assign(Object.assign({}, d), {}, {
                                    printWidth: Number.POSITIVE_INFINITY
                                })).formatted)), B.push(h, "`"), C.each((R)=>{
                                let q = R.getName();
                                if (B.push(o()), q < k.length) {
                                    let { tabWidth: J } = d, L = R.getValue(), Q = a2(L.value.raw, J), V = k[q];
                                    if (!M) {
                                        let Y = v[b][q];
                                        (E(Y) || N(Y) || Y.type === "ConditionalExpression" || Y.type === "SequenceExpression" || x(Y) || F(Y)) && (V = [
                                            p([
                                                i,
                                                V
                                            ]),
                                            i
                                        ]);
                                    }
                                    let j = Q === 0 && L.value.raw.endsWith(`
`) ? y(Number.NEGATIVE_INFINITY, V) : g(V, Q, J);
                                    B.push(l([
                                        "${",
                                        j,
                                        h,
                                        "}"
                                    ]));
                                }
                            }, "quasis"), B.push("`"), B;
                        }
                        function P(C, o, d) {
                            let v = C.getNode(), S = v.quasis[0].value.raw.trim().split(/\s*\|\s*/);
                            if (S.length > 1 || S.some((b)=>b.length > 0)) {
                                o.__inJestEach = true;
                                let b = C.map(d, "expressions");
                                o.__inJestEach = false;
                                let B = [], k = b.map((L)=>"${" + c(L, Object.assign(Object.assign({}, o), {}, {
                                        printWidth: Number.POSITIVE_INFINITY,
                                        endOfLine: "lf"
                                    })).formatted + "}"), M = [
                                    {
                                        hasLineBreak: false,
                                        cells: []
                                    }
                                ];
                                for(let L = 1; L < v.quasis.length; L++){
                                    let Q = t1(M), V = k[L - 1];
                                    Q.cells.push(V), V.includes(`
`) && (Q.hasLineBreak = true), v.quasis[L].value.raw.includes(`
`) && M.push({
                                        hasLineBreak: false,
                                        cells: []
                                    });
                                }
                                let R = Math.max(S.length, ...M.map((L)=>L.cells.length)), q = Array.from({
                                    length: R
                                }).fill(0), J = [
                                    {
                                        cells: S
                                    },
                                    ...M.filter((L)=>L.cells.length > 0)
                                ];
                                for (let { cells: L } of J.filter((Q)=>!Q.hasLineBreak))for (let [Q, V] of L.entries())q[Q] = Math.max(q[Q], s(V));
                                return B.push(h, "`", p([
                                    u,
                                    n(u, J.map((L)=>n(" | ", L.cells.map((Q, V)=>L.hasLineBreak ? Q : Q + " ".repeat(q[V] - s(Q))))))
                                ]), u, "`"), B;
                            }
                        }
                        function $(C, o) {
                            let d = C.getValue(), v = o();
                            return E(d) && (v = l([
                                p([
                                    i,
                                    v
                                ]),
                                i
                            ])), [
                                "${",
                                v,
                                h,
                                "}"
                            ];
                        }
                        function D(C, o) {
                            return C.map((d)=>$(d, o), "expressions");
                        }
                        function T(C, o) {
                            return f2(C, (d)=>typeof d == "string" ? o ? d.replace(/(\\*)`/g, "$1$1\\`") : m(d) : d);
                        }
                        function m(C) {
                            return C.replace(/([\\`]|\${)/g, "\\$1");
                        }
                        r.exports = {
                            printTemplateLiteral: I,
                            printTemplateExpressions: D,
                            escapeTemplateCharacters: T,
                            uncookTemplateElementValue: m
                        };
                    }
                }), Ym = te({
                    "src/language-js/embed/markdown.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { indent: t1, softline: s, literalline: a2, dedentToRoot: n } } = qe(), { escapeTemplateCharacters: u } = jt();
                        function i(p, y, h) {
                            let c = p.getValue().quasis[0].value.raw.replace(/((?:\\\\)*)\\`/g, (w, E)=>"\\".repeat(E.length / 2) + "`"), f2 = l(c), F = f2 !== "";
                            F && (c = c.replace(new RegExp(`^${f2}`, "gm"), ""));
                            let _2 = u(h(c, {
                                parser: "markdown",
                                __inJsTemplate: true
                            }, {
                                stripTrailingHardline: true
                            }), true);
                            return [
                                "`",
                                F ? t1([
                                    s,
                                    _2
                                ]) : [
                                    a2,
                                    n(_2)
                                ],
                                s,
                                "`"
                            ];
                        }
                        function l(p) {
                            let y = p.match(/^([^\S\n]*)\S/m);
                            return y === null ? "" : y[1];
                        }
                        r.exports = i;
                    }
                }), Qm = te({
                    "src/language-js/embed/css.js" (e, r) {
                        "use strict";
                        ne();
                        var { isNonEmptyArray: t1 } = Ue(), { builders: { indent: s, hardline: a2, softline: n }, utils: { mapDoc: u, replaceEndOfLine: i, cleanDoc: l } } = qe(), { printTemplateExpressions: p } = jt();
                        function y(c, f2, F) {
                            let _2 = c.getValue(), w = _2.quasis.map((P)=>P.value.raw), E = 0, N = w.reduce((P, $, D)=>D === 0 ? $ : P + "@prettier-placeholder-" + E++ + "-id" + $, ""), x = F(N, {
                                parser: "scss"
                            }, {
                                stripTrailingHardline: true
                            }), I = p(c, f2);
                            return h(x, _2, I);
                        }
                        function h(c, f2, F) {
                            if (f2.quasis.length === 1 && !f2.quasis[0].value.raw.trim()) return "``";
                            let w = g(c, F);
                            if (!w) throw new Error("Couldn't insert all the expressions");
                            return [
                                "`",
                                s([
                                    a2,
                                    w
                                ]),
                                n,
                                "`"
                            ];
                        }
                        function g(c, f2) {
                            if (!t1(f2)) return c;
                            let F = 0, _2 = u(l(c), (w)=>typeof w != "string" || !w.includes("@prettier-placeholder") ? w : w.split(/@prettier-placeholder-(\d+)-id/).map((E, N)=>N % 2 === 0 ? i(E) : (F++, f2[E])));
                            return f2.length === F ? _2 : null;
                        }
                        r.exports = y;
                    }
                }), Zm = te({
                    "src/language-js/embed/graphql.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { indent: t1, join: s, hardline: a2 } } = qe(), { escapeTemplateCharacters: n, printTemplateExpressions: u } = jt();
                        function i(p, y, h) {
                            let g = p.getValue(), c = g.quasis.length;
                            if (c === 1 && g.quasis[0].value.raw.trim() === "") return "``";
                            let f2 = u(p, y), F = [];
                            for(let _2 = 0; _2 < c; _2++){
                                let w = g.quasis[_2], E = _2 === 0, N = _2 === c - 1, x = w.value.cooked, I = x.split(`
`), P = I.length, $ = f2[_2], D = P > 2 && I[0].trim() === "" && I[1].trim() === "", T = P > 2 && I[P - 1].trim() === "" && I[P - 2].trim() === "", m = I.every((o)=>/^\s*(?:#[^\n\r]*)?$/.test(o));
                                if (!N && /#[^\n\r]*$/.test(I[P - 1])) return null;
                                let C = null;
                                m ? C = l(I) : C = h(x, {
                                    parser: "graphql"
                                }, {
                                    stripTrailingHardline: true
                                }), C ? (C = n(C, false), !E && D && F.push(""), F.push(C), !N && T && F.push("")) : !E && !N && D && F.push(""), $ && F.push($);
                            }
                            return [
                                "`",
                                t1([
                                    a2,
                                    s(a2, F)
                                ]),
                                a2,
                                "`"
                            ];
                        }
                        function l(p) {
                            let y = [], h = false, g = p.map((c)=>c.trim());
                            for (let [c, f2] of g.entries())f2 !== "" && (g[c - 1] === "" && h ? y.push([
                                a2,
                                f2
                            ]) : y.push(f2), h = true);
                            return y.length === 0 ? null : s(a2, y);
                        }
                        r.exports = i;
                    }
                }), ed = te({
                    "src/language-js/embed/html.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { indent: t1, line: s, hardline: a2, group: n }, utils: { mapDoc: u } } = qe(), { printTemplateExpressions: i, uncookTemplateElementValue: l } = jt(), p = 0;
                        function y(h, g, c, f2, F) {
                            let { parser: _2 } = F, w = h.getValue(), E = p;
                            p = p + 1 >>> 0;
                            let N = (d)=>`PRETTIER_HTML_PLACEHOLDER_${d}_${E}_IN_JS`, x = w.quasis.map((d, v, S)=>v === S.length - 1 ? d.value.cooked : d.value.cooked + N(v)).join(""), I = i(h, g);
                            if (I.length === 0 && x.trim().length === 0) return "``";
                            let P = new RegExp(N("(\\d+)"), "g"), $ = 0, D = c(x, {
                                parser: _2,
                                __onHtmlRoot (d) {
                                    $ = d.children.length;
                                }
                            }, {
                                stripTrailingHardline: true
                            }), T = u(D, (d)=>{
                                if (typeof d != "string") return d;
                                let v = [], S = d.split(P);
                                for(let b = 0; b < S.length; b++){
                                    let B = S[b];
                                    if (b % 2 === 0) {
                                        B && (B = l(B), f2.__embeddedInHtml && (B = B.replace(/<\/(script)\b/gi, "<\\/$1")), v.push(B));
                                        continue;
                                    }
                                    let k = Number(B);
                                    v.push(I[k]);
                                }
                                return v;
                            }), m = /^\s/.test(x) ? " " : "", C = /\s$/.test(x) ? " " : "", o = f2.htmlWhitespaceSensitivity === "ignore" ? a2 : m && C ? s : null;
                            return n(o ? [
                                "`",
                                t1([
                                    o,
                                    n(T)
                                ]),
                                o,
                                "`"
                            ] : [
                                "`",
                                m,
                                $ > 1 ? t1(n(T)) : n(T),
                                C,
                                "`"
                            ]);
                        }
                        r.exports = y;
                    }
                }), td = te({
                    "src/language-js/embed.js" (e, r) {
                        "use strict";
                        ne();
                        var { hasComment: t1, CommentCheckFlags: s, isObjectProperty: a2 } = Ke(), n = Ym(), u = Qm(), i = Zm(), l = ed();
                        function p(D) {
                            if (g(D) || _2(D) || w(D) || c(D)) return "css";
                            if (x(D)) return "graphql";
                            if (P(D)) return "html";
                            if (f2(D)) return "angular";
                            if (h(D)) return "markdown";
                        }
                        function y(D, T, m, C) {
                            let o = D.getValue();
                            if (o.type !== "TemplateLiteral" || $(o)) return;
                            let d = p(D);
                            if (d) {
                                if (d === "markdown") return n(D, T, m);
                                if (d === "css") return u(D, T, m);
                                if (d === "graphql") return i(D, T, m);
                                if (d === "html" || d === "angular") return l(D, T, m, C, {
                                    parser: d
                                });
                            }
                        }
                        function h(D) {
                            let T = D.getValue(), m = D.getParentNode();
                            return m && m.type === "TaggedTemplateExpression" && T.quasis.length === 1 && m.tag.type === "Identifier" && (m.tag.name === "md" || m.tag.name === "markdown");
                        }
                        function g(D) {
                            let T = D.getValue(), m = D.getParentNode(), C = D.getParentNode(1);
                            return C && T.quasis && m.type === "JSXExpressionContainer" && C.type === "JSXElement" && C.openingElement.name.name === "style" && C.openingElement.attributes.some((o)=>o.name.name === "jsx") || m && m.type === "TaggedTemplateExpression" && m.tag.type === "Identifier" && m.tag.name === "css" || m && m.type === "TaggedTemplateExpression" && m.tag.type === "MemberExpression" && m.tag.object.name === "css" && (m.tag.property.name === "global" || m.tag.property.name === "resolve");
                        }
                        function c(D) {
                            return D.match((T)=>T.type === "TemplateLiteral", (T, m)=>T.type === "ArrayExpression" && m === "elements", (T, m)=>a2(T) && T.key.type === "Identifier" && T.key.name === "styles" && m === "value", ...F);
                        }
                        function f2(D) {
                            return D.match((T)=>T.type === "TemplateLiteral", (T, m)=>a2(T) && T.key.type === "Identifier" && T.key.name === "template" && m === "value", ...F);
                        }
                        var F = [
                            (D, T)=>D.type === "ObjectExpression" && T === "properties",
                            (D, T)=>D.type === "CallExpression" && D.callee.type === "Identifier" && D.callee.name === "Component" && T === "arguments",
                            (D, T)=>D.type === "Decorator" && T === "expression"
                        ];
                        function _2(D) {
                            let T = D.getParentNode();
                            if (!T || T.type !== "TaggedTemplateExpression") return false;
                            let m = T.tag.type === "ParenthesizedExpression" ? T.tag.expression : T.tag;
                            switch(m.type){
                                case "MemberExpression":
                                    return E(m.object) || N(m);
                                case "CallExpression":
                                    return E(m.callee) || m.callee.type === "MemberExpression" && (m.callee.object.type === "MemberExpression" && (E(m.callee.object.object) || N(m.callee.object)) || m.callee.object.type === "CallExpression" && E(m.callee.object.callee));
                                case "Identifier":
                                    return m.name === "css";
                                default:
                                    return false;
                            }
                        }
                        function w(D) {
                            let T = D.getParentNode(), m = D.getParentNode(1);
                            return m && T.type === "JSXExpressionContainer" && m.type === "JSXAttribute" && m.name.type === "JSXIdentifier" && m.name.name === "css";
                        }
                        function E(D) {
                            return D.type === "Identifier" && D.name === "styled";
                        }
                        function N(D) {
                            return /^[A-Z]/.test(D.object.name) && D.property.name === "extend";
                        }
                        function x(D) {
                            let T = D.getValue(), m = D.getParentNode();
                            return I(T, "GraphQL") || m && (m.type === "TaggedTemplateExpression" && (m.tag.type === "MemberExpression" && m.tag.object.name === "graphql" && m.tag.property.name === "experimental" || m.tag.type === "Identifier" && (m.tag.name === "gql" || m.tag.name === "graphql")) || m.type === "CallExpression" && m.callee.type === "Identifier" && m.callee.name === "graphql");
                        }
                        function I(D, T) {
                            return t1(D, s.Block | s.Leading, (m)=>{
                                let { value: C } = m;
                                return C === ` ${T} `;
                            });
                        }
                        function P(D) {
                            return I(D.getValue(), "HTML") || D.match((T)=>T.type === "TemplateLiteral", (T, m)=>T.type === "TaggedTemplateExpression" && T.tag.type === "Identifier" && T.tag.name === "html" && m === "quasi");
                        }
                        function $(D) {
                            let { quasis: T } = D;
                            return T.some((m)=>{
                                let { value: { cooked: C } } = m;
                                return C === null;
                            });
                        }
                        r.exports = y;
                    }
                }), rd = te({
                    "src/language-js/clean.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Pt(), s = /* @__PURE__ */ new Set([
                            "range",
                            "raw",
                            "comments",
                            "leadingComments",
                            "trailingComments",
                            "innerComments",
                            "extra",
                            "start",
                            "end",
                            "loc",
                            "flags",
                            "errors",
                            "tokens"
                        ]), a2 = (u)=>{
                            for (let i of u.quasis)delete i.value;
                        };
                        function n(u, i, l) {
                            if (u.type === "Program" && delete i.sourceType, (u.type === "BigIntLiteral" || u.type === "BigIntLiteralTypeAnnotation") && i.value && (i.value = i.value.toLowerCase()), (u.type === "BigIntLiteral" || u.type === "Literal") && i.bigint && (i.bigint = i.bigint.toLowerCase()), u.type === "DecimalLiteral" && (i.value = Number(i.value)), u.type === "Literal" && i.decimal && (i.decimal = Number(i.decimal)), u.type === "EmptyStatement" || u.type === "JSXText" || u.type === "JSXExpressionContainer" && (u.expression.type === "Literal" || u.expression.type === "StringLiteral") && u.expression.value === " ") return null;
                            if ((u.type === "Property" || u.type === "ObjectProperty" || u.type === "MethodDefinition" || u.type === "ClassProperty" || u.type === "ClassMethod" || u.type === "PropertyDefinition" || u.type === "TSDeclareMethod" || u.type === "TSPropertySignature" || u.type === "ObjectTypeProperty") && typeof u.key == "object" && u.key && (u.key.type === "Literal" || u.key.type === "NumericLiteral" || u.key.type === "StringLiteral" || u.key.type === "Identifier") && delete i.key, u.type === "JSXElement" && u.openingElement.name.name === "style" && u.openingElement.attributes.some((h)=>h.name.name === "jsx")) for (let { type: h, expression: g } of i.children)h === "JSXExpressionContainer" && g.type === "TemplateLiteral" && a2(g);
                            u.type === "JSXAttribute" && u.name.name === "css" && u.value.type === "JSXExpressionContainer" && u.value.expression.type === "TemplateLiteral" && a2(i.value.expression), u.type === "JSXAttribute" && u.value && u.value.type === "Literal" && /["']|&quot;|&apos;/.test(u.value.value) && (i.value.value = i.value.value.replace(/["']|&quot;|&apos;/g, '"'));
                            let p = u.expression || u.callee;
                            if (u.type === "Decorator" && p.type === "CallExpression" && p.callee.name === "Component" && p.arguments.length === 1) {
                                let h = u.expression.arguments[0].properties;
                                for (let [g, c] of i.expression.arguments[0].properties.entries())switch(h[g].key.name){
                                    case "styles":
                                        c.value.type === "ArrayExpression" && a2(c.value.elements[0]);
                                        break;
                                    case "template":
                                        c.value.type === "TemplateLiteral" && a2(c.value);
                                        break;
                                }
                            }
                            if (u.type === "TaggedTemplateExpression" && (u.tag.type === "MemberExpression" || u.tag.type === "Identifier" && (u.tag.name === "gql" || u.tag.name === "graphql" || u.tag.name === "css" || u.tag.name === "md" || u.tag.name === "markdown" || u.tag.name === "html") || u.tag.type === "CallExpression") && a2(i.quasi), u.type === "TemplateLiteral") {
                                var y;
                                (((y = u.leadingComments) === null || y === void 0 ? void 0 : y.some((g)=>t1(g) && [
                                        "GraphQL",
                                        "HTML"
                                    ].some((c)=>g.value === ` ${c} `))) || l.type === "CallExpression" && l.callee.name === "graphql" || !u.leadingComments) && a2(i);
                            }
                            if (u.type === "InterpreterDirective" && (i.value = i.value.trimEnd()), (u.type === "TSIntersectionType" || u.type === "TSUnionType") && u.types.length === 1) return i.types[0];
                        }
                        n.ignoredProperties = s, r.exports = n;
                    }
                }), io = {};
                Kt(io, {
                    EOL: ()=>Wn,
                    arch: ()=>nd,
                    cpus: ()=>Do,
                    default: ()=>vo,
                    endianness: ()=>ao,
                    freemem: ()=>po,
                    getNetworkInterfaces: ()=>ho,
                    hostname: ()=>oo,
                    loadavg: ()=>lo,
                    networkInterfaces: ()=>yo,
                    platform: ()=>ud,
                    release: ()=>go,
                    tmpDir: ()=>$n,
                    tmpdir: ()=>Vn,
                    totalmem: ()=>fo,
                    type: ()=>mo,
                    uptime: ()=>co
                });
                function ao() {
                    if (typeof Tr > "u") {
                        var e = new ArrayBuffer(2), r = new Uint8Array(e), t1 = new Uint16Array(e);
                        if (r[0] = 1, r[1] = 2, t1[0] === 258) Tr = "BE";
                        else if (t1[0] === 513) Tr = "LE";
                        else throw new Error("unable to figure out endianess");
                    }
                    return Tr;
                }
                function oo() {
                    return typeof globalThis.location < "u" ? globalThis.location.hostname : "";
                }
                function lo() {
                    return [];
                }
                function co() {
                    return 0;
                }
                function po() {
                    return Number.MAX_VALUE;
                }
                function fo() {
                    return Number.MAX_VALUE;
                }
                function Do() {
                    return [];
                }
                function mo() {
                    return "Browser";
                }
                function go() {
                    return typeof globalThis.navigator < "u" ? globalThis.navigator.appVersion : "";
                }
                function yo() {}
                function ho() {}
                function nd() {
                    return "javascript";
                }
                function ud() {
                    return "browser";
                }
                function $n() {
                    return "/tmp";
                }
                var Tr, Vn, Wn, vo, sd = ht({
                    "node-modules-polyfills:os" () {
                        ne(), Vn = $n, Wn = `
`, vo = {
                            EOL: Wn,
                            tmpdir: Vn,
                            tmpDir: $n,
                            networkInterfaces: yo,
                            getNetworkInterfaces: ho,
                            release: go,
                            type: mo,
                            cpus: Do,
                            totalmem: fo,
                            freemem: po,
                            uptime: co,
                            loadavg: lo,
                            hostname: oo,
                            endianness: ao
                        };
                    }
                }), id = te({
                    "node-modules-polyfills-commonjs:os" (e, r) {
                        ne();
                        var t1 = (sd(), ft(io));
                        if (t1 && t1.default) {
                            r.exports = t1.default;
                            for(let s in t1)r.exports[s] = t1[s];
                        } else t1 && (r.exports = t1);
                    }
                }), ad = te({
                    "node_modules/detect-newline/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = (s)=>{
                            if (typeof s != "string") throw new TypeError("Expected a string");
                            let a2 = s.match(/(?:\r?\n)/g) || [];
                            if (a2.length === 0) return;
                            let n = a2.filter((i)=>i === `\r
`).length, u = a2.length - n;
                            return n > u ? `\r
` : `
`;
                        };
                        r.exports = t1, r.exports.graceful = (s)=>typeof s == "string" && t1(s) || `
`;
                    }
                }), od = te({
                    "node_modules/jest-docblock/build/index.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        }), e.extract = c, e.parse = F, e.parseWithComments = _2, e.print = w, e.strip = f2;
                        function r() {
                            let N = id();
                            return r = function() {
                                return N;
                            }, N;
                        }
                        function t1() {
                            let N = s(ad());
                            return t1 = function() {
                                return N;
                            }, N;
                        }
                        function s(N) {
                            return N && N.__esModule ? N : {
                                default: N
                            };
                        }
                        var a2 = /\*\/$/, n = /^\/\*\*?/, u = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/, i = /(^|\s+)\/\/([^\r\n]*)/g, l = /^(\r?\n)+/, p = /(?:^|\r?\n) *(@[^\r\n]*?) *\r?\n *(?![^@\r\n]*\/\/[^]*)([^@\r\n\s][^@\r\n]+?) *\r?\n/g, y = /(?:^|\r?\n) *@(\S+) *([^\r\n]*)/g, h = /(\r?\n|^) *\* ?/g, g = [];
                        function c(N) {
                            let x = N.match(u);
                            return x ? x[0].trimLeft() : "";
                        }
                        function f2(N) {
                            let x = N.match(u);
                            return x && x[0] ? N.substring(x[0].length) : N;
                        }
                        function F(N) {
                            return _2(N).pragmas;
                        }
                        function _2(N) {
                            let x = (0, t1().default)(N) || r().EOL;
                            N = N.replace(n, "").replace(a2, "").replace(h, "$1");
                            let I = "";
                            for(; I !== N;)I = N, N = N.replace(p, `${x}$1 $2${x}`);
                            N = N.replace(l, "").trimRight();
                            let P = /* @__PURE__ */ Object.create(null), $ = N.replace(y, "").replace(l, "").trimRight(), D;
                            for(; D = y.exec(N);){
                                let T = D[2].replace(i, "");
                                typeof P[D[1]] == "string" || Array.isArray(P[D[1]]) ? P[D[1]] = g.concat(P[D[1]], T) : P[D[1]] = T;
                            }
                            return {
                                comments: $,
                                pragmas: P
                            };
                        }
                        function w(N) {
                            let { comments: x = "", pragmas: I = {} } = N, P = (0, t1().default)(x) || r().EOL, $ = "/**", D = " *", T = " */", m = Object.keys(I), C = m.map((d)=>E(d, I[d])).reduce((d, v)=>d.concat(v), []).map((d)=>`${D} ${d}${P}`).join("");
                            if (!x) {
                                if (m.length === 0) return "";
                                if (m.length === 1 && !Array.isArray(I[m[0]])) {
                                    let d = I[m[0]];
                                    return `${$} ${E(m[0], d)[0]}${T}`;
                                }
                            }
                            let o = x.split(P).map((d)=>`${D} ${d}`).join(P) + P;
                            return $ + P + (x ? o : "") + (x && m.length ? D + P : "") + C + T;
                        }
                        function E(N, x) {
                            return g.concat(x).map((I)=>`@${N} ${I}`.trim());
                        }
                    }
                }), ld = te({
                    "src/language-js/utils/get-shebang.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s) {
                            if (!s.startsWith("#!")) return "";
                            let a2 = s.indexOf(`
`);
                            return a2 === -1 ? s : s.slice(0, a2);
                        }
                        r.exports = t1;
                    }
                }), Co = te({
                    "src/language-js/pragma.js" (e, r) {
                        "use strict";
                        ne();
                        var { parseWithComments: t1, strip: s, extract: a2, print: n } = od(), { normalizeEndOfLine: u } = Jn(), i = ld();
                        function l(h) {
                            let g = i(h);
                            g && (h = h.slice(g.length + 1));
                            let c = a2(h), { pragmas: f2, comments: F } = t1(c);
                            return {
                                shebang: g,
                                text: h,
                                pragmas: f2,
                                comments: F
                            };
                        }
                        function p(h) {
                            let g = Object.keys(l(h).pragmas);
                            return g.includes("prettier") || g.includes("format");
                        }
                        function y(h) {
                            let { shebang: g, text: c, pragmas: f2, comments: F } = l(h), _2 = s(c), w = n({
                                pragmas: Object.assign({
                                    format: ""
                                }, f2),
                                comments: F.trimStart()
                            });
                            return (g ? `${g}
` : "") + u(w) + (_2.startsWith(`
`) ? `
` : `

`) + _2;
                        }
                        r.exports = {
                            hasPragma: p,
                            insertPragma: y
                        };
                    }
                }), cd = te({
                    "src/language-js/utils/is-type-cast-comment.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Pt();
                        function s(a2) {
                            return t1(a2) && a2.value[0] === "*" && /@(?:type|satisfies)\b/.test(a2.value);
                        }
                        r.exports = s;
                    }
                }), Eo = te({
                    "src/language-js/comments.js" (e, r) {
                        "use strict";
                        ne();
                        var { getLast: t1, hasNewline: s, getNextNonSpaceNonCommentCharacterIndexWithStartIndex: a2, getNextNonSpaceNonCommentCharacter: n, hasNewlineInRange: u, addLeadingComment: i, addTrailingComment: l, addDanglingComment: p, getNextNonSpaceNonCommentCharacterIndex: y, isNonEmptyArray: h } = Ue(), { getFunctionParameters: g, isPrettierIgnoreComment: c, isJsxNode: f2, hasFlowShorthandAnnotationComment: F, hasFlowAnnotationComment: _2, hasIgnoreComment: w, isCallLikeExpression: E, getCallArguments: N, isCallExpression: x, isMemberExpression: I, isObjectProperty: P, isLineComment: $, getComments: D, CommentCheckFlags: T, markerForIfWithoutBlockAndSameLineComment: m } = Ke(), { locStart: C, locEnd: o } = ut(), d = Pt(), v = cd();
                        function S(De) {
                            return [
                                H,
                                Fe,
                                Q,
                                q,
                                J,
                                L,
                                ie,
                                he,
                                se,
                                ge,
                                we,
                                ke,
                                ce,
                                z,
                                U
                            ].some((A2)=>A2(De));
                        }
                        function b(De) {
                            return [
                                R,
                                Fe,
                                V,
                                we,
                                q,
                                J,
                                L,
                                ie,
                                z,
                                Z,
                                fe,
                                ge,
                                Pe,
                                U,
                                X
                            ].some((A2)=>A2(De));
                        }
                        function B(De) {
                            return [
                                H,
                                q,
                                J,
                                j,
                                ue,
                                ce,
                                ge,
                                de,
                                K,
                                pe,
                                U,
                                oe
                            ].some((A2)=>A2(De));
                        }
                        function k(De, A2) {
                            let G = (De.body || De.properties).find((re)=>{
                                let { type: ye } = re;
                                return ye !== "EmptyStatement";
                            });
                            G ? i(G, A2) : p(De, A2);
                        }
                        function M(De, A2) {
                            De.type === "BlockStatement" ? k(De, A2) : i(De, A2);
                        }
                        function R(De) {
                            let { comment: A2, followingNode: G } = De;
                            return G && v(A2) ? (i(G, A2), true) : false;
                        }
                        function q(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, followingNode: ye, text: Ce } = De;
                            if ((re == null ? void 0 : re.type) !== "IfStatement" || !ye) return false;
                            if (n(Ce, A2, o) === ")") return l(G, A2), true;
                            if (G === re.consequent && ye === re.alternate) {
                                if (G.type === "BlockStatement") l(G, A2);
                                else {
                                    let ve = A2.type === "SingleLine" || A2.loc.start.line === A2.loc.end.line, ze = A2.loc.start.line === G.loc.start.line;
                                    ve && ze ? p(G, A2, m) : p(re, A2);
                                }
                                return true;
                            }
                            return ye.type === "BlockStatement" ? (k(ye, A2), true) : ye.type === "IfStatement" ? (M(ye.consequent, A2), true) : re.consequent === ye ? (i(ye, A2), true) : false;
                        }
                        function J(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, followingNode: ye, text: Ce } = De;
                            return (re == null ? void 0 : re.type) !== "WhileStatement" || !ye ? false : n(Ce, A2, o) === ")" ? (l(G, A2), true) : ye.type === "BlockStatement" ? (k(ye, A2), true) : re.body === ye ? (i(ye, A2), true) : false;
                        }
                        function L(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, followingNode: ye } = De;
                            return (re == null ? void 0 : re.type) !== "TryStatement" && (re == null ? void 0 : re.type) !== "CatchClause" || !ye ? false : re.type === "CatchClause" && G ? (l(G, A2), true) : ye.type === "BlockStatement" ? (k(ye, A2), true) : ye.type === "TryStatement" ? (M(ye.finalizer, A2), true) : ye.type === "CatchClause" ? (M(ye.body, A2), true) : false;
                        }
                        function Q(De) {
                            let { comment: A2, enclosingNode: G, followingNode: re } = De;
                            return I(G) && (re == null ? void 0 : re.type) === "Identifier" ? (i(G, A2), true) : false;
                        }
                        function V(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, followingNode: ye, text: Ce } = De, Be = G && !u(Ce, o(G), C(A2));
                            return (!G || !Be) && ((re == null ? void 0 : re.type) === "ConditionalExpression" || (re == null ? void 0 : re.type) === "TSConditionalType") && ye ? (i(ye, A2), true) : false;
                        }
                        function j(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re } = De;
                            return P(re) && re.shorthand && re.key === G && re.value.type === "AssignmentPattern" ? (l(re.value.left, A2), true) : false;
                        }
                        var Y = /* @__PURE__ */ new Set([
                            "ClassDeclaration",
                            "ClassExpression",
                            "DeclareClass",
                            "DeclareInterface",
                            "InterfaceDeclaration",
                            "TSInterfaceDeclaration"
                        ]);
                        function ie(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, followingNode: ye } = De;
                            if (Y.has(re == null ? void 0 : re.type)) {
                                if (h(re.decorators) && !(ye && ye.type === "Decorator")) return l(t1(re.decorators), A2), true;
                                if (re.body && ye === re.body) return k(re.body, A2), true;
                                if (ye) {
                                    if (re.superClass && ye === re.superClass && G && (G === re.id || G === re.typeParameters)) return l(G, A2), true;
                                    for (let Ce of [
                                        "implements",
                                        "extends",
                                        "mixins"
                                    ])if (re[Ce] && ye === re[Ce][0]) return G && (G === re.id || G === re.typeParameters || G === re.superClass) ? l(G, A2) : p(re, A2, Ce), true;
                                }
                            }
                            return false;
                        }
                        var ee = /* @__PURE__ */ new Set([
                            "ClassMethod",
                            "ClassProperty",
                            "PropertyDefinition",
                            "TSAbstractPropertyDefinition",
                            "TSAbstractMethodDefinition",
                            "TSDeclareMethod",
                            "MethodDefinition",
                            "ClassAccessorProperty",
                            "AccessorProperty",
                            "TSAbstractAccessorProperty"
                        ]);
                        function ce(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, text: ye } = De;
                            return re && G && n(ye, A2, o) === "(" && (re.type === "Property" || re.type === "TSDeclareMethod" || re.type === "TSAbstractMethodDefinition") && G.type === "Identifier" && re.key === G && n(ye, G, o) !== ":" || (G == null ? void 0 : G.type) === "Decorator" && ee.has(re == null ? void 0 : re.type) ? (l(G, A2), true) : false;
                        }
                        var W = /* @__PURE__ */ new Set([
                            "FunctionDeclaration",
                            "FunctionExpression",
                            "ClassMethod",
                            "MethodDefinition",
                            "ObjectMethod"
                        ]);
                        function K(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, text: ye } = De;
                            return n(ye, A2, o) !== "(" ? false : G && W.has(re == null ? void 0 : re.type) ? (l(G, A2), true) : false;
                        }
                        function de(De) {
                            let { comment: A2, enclosingNode: G, text: re } = De;
                            if ((G == null ? void 0 : G.type) !== "ArrowFunctionExpression") return false;
                            let ye = y(re, A2, o);
                            return ye !== false && re.slice(ye, ye + 2) === "=>" ? (p(G, A2), true) : false;
                        }
                        function ue(De) {
                            let { comment: A2, enclosingNode: G, text: re } = De;
                            return n(re, A2, o) !== ")" ? false : G && (le(G) && g(G).length === 0 || E(G) && N(G).length === 0) ? (p(G, A2), true) : ((G == null ? void 0 : G.type) === "MethodDefinition" || (G == null ? void 0 : G.type) === "TSAbstractMethodDefinition") && g(G.value).length === 0 ? (p(G.value, A2), true) : false;
                        }
                        function Fe(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, followingNode: ye, text: Ce } = De;
                            if ((G == null ? void 0 : G.type) === "FunctionTypeParam" && (re == null ? void 0 : re.type) === "FunctionTypeAnnotation" && (ye == null ? void 0 : ye.type) !== "FunctionTypeParam" || ((G == null ? void 0 : G.type) === "Identifier" || (G == null ? void 0 : G.type) === "AssignmentPattern") && re && le(re) && n(Ce, A2, o) === ")") return l(G, A2), true;
                            if ((re == null ? void 0 : re.type) === "FunctionDeclaration" && (ye == null ? void 0 : ye.type) === "BlockStatement") {
                                let Be = (()=>{
                                    let ve = g(re);
                                    if (ve.length > 0) return a2(Ce, o(t1(ve)));
                                    let ze = a2(Ce, o(re.id));
                                    return ze !== false && a2(Ce, ze + 1);
                                })();
                                if (C(A2) > Be) return k(ye, A2), true;
                            }
                            return false;
                        }
                        function z(De) {
                            let { comment: A2, enclosingNode: G } = De;
                            return (G == null ? void 0 : G.type) === "LabeledStatement" ? (i(G, A2), true) : false;
                        }
                        function U(De) {
                            let { comment: A2, enclosingNode: G } = De;
                            return ((G == null ? void 0 : G.type) === "ContinueStatement" || (G == null ? void 0 : G.type) === "BreakStatement") && !G.label ? (l(G, A2), true) : false;
                        }
                        function Z(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re } = De;
                            return x(re) && G && re.callee === G && re.arguments.length > 0 ? (i(re.arguments[0], A2), true) : false;
                        }
                        function se(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, followingNode: ye } = De;
                            return (re == null ? void 0 : re.type) === "UnionTypeAnnotation" || (re == null ? void 0 : re.type) === "TSUnionType" ? (c(A2) && (ye.prettierIgnore = true, A2.unignore = true), G ? (l(G, A2), true) : false) : (((ye == null ? void 0 : ye.type) === "UnionTypeAnnotation" || (ye == null ? void 0 : ye.type) === "TSUnionType") && c(A2) && (ye.types[0].prettierIgnore = true, A2.unignore = true), false);
                        }
                        function fe(De) {
                            let { comment: A2, enclosingNode: G } = De;
                            return P(G) ? (i(G, A2), true) : false;
                        }
                        function ge(De) {
                            let { comment: A2, enclosingNode: G, followingNode: re, ast: ye, isLastComment: Ce } = De;
                            return ye && ye.body && ye.body.length === 0 ? (Ce ? p(ye, A2) : i(ye, A2), true) : (G == null ? void 0 : G.type) === "Program" && (G == null ? void 0 : G.body.length) === 0 && !h(G.directives) ? (Ce ? p(G, A2) : i(G, A2), true) : (re == null ? void 0 : re.type) === "Program" && (re == null ? void 0 : re.body.length) === 0 && (G == null ? void 0 : G.type) === "ModuleExpression" ? (p(re, A2), true) : false;
                        }
                        function he(De) {
                            let { comment: A2, enclosingNode: G } = De;
                            return (G == null ? void 0 : G.type) === "ForInStatement" || (G == null ? void 0 : G.type) === "ForOfStatement" ? (i(G, A2), true) : false;
                        }
                        function we(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, text: ye } = De;
                            if ((re == null ? void 0 : re.type) === "ImportSpecifier" || (re == null ? void 0 : re.type) === "ExportSpecifier") return i(re, A2), true;
                            let Ce = (G == null ? void 0 : G.type) === "ImportSpecifier" && (re == null ? void 0 : re.type) === "ImportDeclaration", Be = (G == null ? void 0 : G.type) === "ExportSpecifier" && (re == null ? void 0 : re.type) === "ExportNamedDeclaration";
                            return (Ce || Be) && s(ye, o(A2)) ? (l(G, A2), true) : false;
                        }
                        function ke(De) {
                            let { comment: A2, enclosingNode: G } = De;
                            return (G == null ? void 0 : G.type) === "AssignmentPattern" ? (i(G, A2), true) : false;
                        }
                        var Re = /* @__PURE__ */ new Set([
                            "VariableDeclarator",
                            "AssignmentExpression",
                            "TypeAlias",
                            "TSTypeAliasDeclaration"
                        ]), Ne = /* @__PURE__ */ new Set([
                            "ObjectExpression",
                            "ArrayExpression",
                            "TemplateLiteral",
                            "TaggedTemplateExpression",
                            "ObjectTypeAnnotation",
                            "TSTypeLiteral"
                        ]);
                        function Pe(De) {
                            let { comment: A2, enclosingNode: G, followingNode: re } = De;
                            return Re.has(G == null ? void 0 : G.type) && re && (Ne.has(re.type) || d(A2)) ? (i(re, A2), true) : false;
                        }
                        function oe(De) {
                            let { comment: A2, enclosingNode: G, followingNode: re, text: ye } = De;
                            return !re && ((G == null ? void 0 : G.type) === "TSMethodSignature" || (G == null ? void 0 : G.type) === "TSDeclareFunction" || (G == null ? void 0 : G.type) === "TSAbstractMethodDefinition") && n(ye, A2, o) === ";" ? (l(G, A2), true) : false;
                        }
                        function H(De) {
                            let { comment: A2, enclosingNode: G, followingNode: re } = De;
                            if (c(A2) && (G == null ? void 0 : G.type) === "TSMappedType" && (re == null ? void 0 : re.type) === "TSTypeParameter" && re.constraint) return G.prettierIgnore = true, A2.unignore = true, true;
                        }
                        function pe(De) {
                            let { comment: A2, precedingNode: G, enclosingNode: re, followingNode: ye } = De;
                            return (re == null ? void 0 : re.type) !== "TSMappedType" ? false : (ye == null ? void 0 : ye.type) === "TSTypeParameter" && ye.name ? (i(ye.name, A2), true) : (G == null ? void 0 : G.type) === "TSTypeParameter" && G.constraint ? (l(G.constraint, A2), true) : false;
                        }
                        function X(De) {
                            let { comment: A2, enclosingNode: G, followingNode: re } = De;
                            return !G || G.type !== "SwitchCase" || G.test || !re || re !== G.consequent[0] ? false : (re.type === "BlockStatement" && $(A2) ? k(re, A2) : p(G, A2), true);
                        }
                        function le(De) {
                            return De.type === "ArrowFunctionExpression" || De.type === "FunctionExpression" || De.type === "FunctionDeclaration" || De.type === "ObjectMethod" || De.type === "ClassMethod" || De.type === "TSDeclareFunction" || De.type === "TSCallSignatureDeclaration" || De.type === "TSConstructSignatureDeclaration" || De.type === "TSMethodSignature" || De.type === "TSConstructorType" || De.type === "TSFunctionType" || De.type === "TSDeclareMethod";
                        }
                        function Ae(De, A2) {
                            if ((A2.parser === "typescript" || A2.parser === "flow" || A2.parser === "acorn" || A2.parser === "espree" || A2.parser === "meriyah" || A2.parser === "__babel_estree") && De.type === "MethodDefinition" && De.value && De.value.type === "FunctionExpression" && g(De.value).length === 0 && !De.value.returnType && !h(De.value.typeParameters) && De.value.body) return [
                                ...De.decorators || [],
                                De.key,
                                De.value.body
                            ];
                        }
                        function Ee(De) {
                            let A2 = De.getValue(), G = De.getParentNode(), re = (ye)=>_2(D(ye, T.Leading)) || _2(D(ye, T.Trailing));
                            return (A2 && (f2(A2) || F(A2) || x(G) && re(A2)) || G && (G.type === "JSXSpreadAttribute" || G.type === "JSXSpreadChild" || G.type === "UnionTypeAnnotation" || G.type === "TSUnionType" || (G.type === "ClassDeclaration" || G.type === "ClassExpression") && G.superClass === A2)) && (!w(De) || G.type === "UnionTypeAnnotation" || G.type === "TSUnionType");
                        }
                        r.exports = {
                            handleOwnLineComment: S,
                            handleEndOfLineComment: b,
                            handleRemainingComment: B,
                            getCommentChildNodes: Ae,
                            willPrintOwnComments: Ee
                        };
                    }
                }), qt = te({
                    "src/language-js/needs-parens.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = lt(), s = Kn(), { getFunctionParameters: a2, getLeftSidePathName: n, hasFlowShorthandAnnotationComment: u, hasNakedLeftSide: i, hasNode: l, isBitwiseOperator: p, startsWithNoLookaheadToken: y, shouldFlatten: h, getPrecedence: g, isCallExpression: c, isMemberExpression: f2, isObjectProperty: F, isTSTypeExpression: _2 } = Ke();
                        function w(D, T) {
                            let m = D.getParentNode();
                            if (!m) return false;
                            let C = D.getName(), o = D.getNode();
                            if (T.__isInHtmlInterpolation && !T.bracketSpacing && I(o) && P(D)) return true;
                            if (E(o)) return false;
                            if (T.parser !== "flow" && u(D.getValue())) return true;
                            if (o.type === "Identifier") {
                                if (o.extra && o.extra.parenthesized && /^PRETTIER_HTML_PLACEHOLDER_\d+_\d+_IN_JS$/.test(o.name) || C === "left" && (o.name === "async" && !m.await || o.name === "let") && m.type === "ForOfStatement") return true;
                                if (o.name === "let") {
                                    var d;
                                    let S = (d = D.findAncestor((b)=>b.type === "ForOfStatement")) === null || d === void 0 ? void 0 : d.left;
                                    if (S && y(S, (b)=>b === o)) return true;
                                }
                                if (C === "object" && o.name === "let" && m.type === "MemberExpression" && m.computed && !m.optional) {
                                    let S = D.findAncestor((B)=>B.type === "ExpressionStatement" || B.type === "ForStatement" || B.type === "ForInStatement"), b = S ? S.type === "ExpressionStatement" ? S.expression : S.type === "ForStatement" ? S.init : S.left : void 0;
                                    if (b && y(b, (B)=>B === o)) return true;
                                }
                                return false;
                            }
                            if (o.type === "ObjectExpression" || o.type === "FunctionExpression" || o.type === "ClassExpression" || o.type === "DoExpression") {
                                var v;
                                let S = (v = D.findAncestor((b)=>b.type === "ExpressionStatement")) === null || v === void 0 ? void 0 : v.expression;
                                if (S && y(S, (b)=>b === o)) return true;
                            }
                            switch(m.type){
                                case "ParenthesizedExpression":
                                    return false;
                                case "ClassDeclaration":
                                case "ClassExpression":
                                    {
                                        if (C === "superClass" && (o.type === "ArrowFunctionExpression" || o.type === "AssignmentExpression" || o.type === "AwaitExpression" || o.type === "BinaryExpression" || o.type === "ConditionalExpression" || o.type === "LogicalExpression" || o.type === "NewExpression" || o.type === "ObjectExpression" || o.type === "SequenceExpression" || o.type === "TaggedTemplateExpression" || o.type === "UnaryExpression" || o.type === "UpdateExpression" || o.type === "YieldExpression" || o.type === "TSNonNullExpression")) return true;
                                        break;
                                    }
                                case "ExportDefaultDeclaration":
                                    return $(D, T) || o.type === "SequenceExpression";
                                case "Decorator":
                                    {
                                        if (C === "expression") {
                                            if (f2(o) && o.computed) return true;
                                            let S = false, b = false, B = o;
                                            for(; B;)switch(B.type){
                                                case "MemberExpression":
                                                    b = true, B = B.object;
                                                    break;
                                                case "CallExpression":
                                                    if (b || S) return T.parser !== "typescript";
                                                    S = true, B = B.callee;
                                                    break;
                                                case "Identifier":
                                                    return false;
                                                case "TaggedTemplateExpression":
                                                    return T.parser !== "typescript";
                                                default:
                                                    return true;
                                            }
                                            return true;
                                        }
                                        break;
                                    }
                                case "ArrowFunctionExpression":
                                    {
                                        if (C === "body" && o.type !== "SequenceExpression" && y(o, (S)=>S.type === "ObjectExpression")) return true;
                                        break;
                                    }
                            }
                            switch(o.type){
                                case "UpdateExpression":
                                    if (m.type === "UnaryExpression") return o.prefix && (o.operator === "++" && m.operator === "+" || o.operator === "--" && m.operator === "-");
                                case "UnaryExpression":
                                    switch(m.type){
                                        case "UnaryExpression":
                                            return o.operator === m.operator && (o.operator === "+" || o.operator === "-");
                                        case "BindExpression":
                                            return true;
                                        case "MemberExpression":
                                        case "OptionalMemberExpression":
                                            return C === "object";
                                        case "TaggedTemplateExpression":
                                            return true;
                                        case "NewExpression":
                                        case "CallExpression":
                                        case "OptionalCallExpression":
                                            return C === "callee";
                                        case "BinaryExpression":
                                            return C === "left" && m.operator === "**";
                                        case "TSNonNullExpression":
                                            return true;
                                        default:
                                            return false;
                                    }
                                case "BinaryExpression":
                                    {
                                        if (m.type === "UpdateExpression" || o.operator === "in" && N(D)) return true;
                                        if (o.operator === "|>" && o.extra && o.extra.parenthesized) {
                                            let S = D.getParentNode(1);
                                            if (S.type === "BinaryExpression" && S.operator === "|>") return true;
                                        }
                                    }
                                case "TSTypeAssertion":
                                case "TSAsExpression":
                                case "TSSatisfiesExpression":
                                case "LogicalExpression":
                                    switch(m.type){
                                        case "TSSatisfiesExpression":
                                        case "TSAsExpression":
                                            return !_2(o);
                                        case "ConditionalExpression":
                                            return _2(o);
                                        case "CallExpression":
                                        case "NewExpression":
                                        case "OptionalCallExpression":
                                            return C === "callee";
                                        case "ClassExpression":
                                        case "ClassDeclaration":
                                            return C === "superClass";
                                        case "TSTypeAssertion":
                                        case "TaggedTemplateExpression":
                                        case "UnaryExpression":
                                        case "JSXSpreadAttribute":
                                        case "SpreadElement":
                                        case "SpreadProperty":
                                        case "BindExpression":
                                        case "AwaitExpression":
                                        case "TSNonNullExpression":
                                        case "UpdateExpression":
                                            return true;
                                        case "MemberExpression":
                                        case "OptionalMemberExpression":
                                            return C === "object";
                                        case "AssignmentExpression":
                                        case "AssignmentPattern":
                                            return C === "left" && (o.type === "TSTypeAssertion" || _2(o));
                                        case "LogicalExpression":
                                            if (o.type === "LogicalExpression") return m.operator !== o.operator;
                                        case "BinaryExpression":
                                            {
                                                let { operator: S, type: b } = o;
                                                if (!S && b !== "TSTypeAssertion") return true;
                                                let B = g(S), k = m.operator, M = g(k);
                                                return M > B || C === "right" && M === B || M === B && !h(k, S) ? true : M < B && S === "%" ? k === "+" || k === "-" : !!p(k);
                                            }
                                        default:
                                            return false;
                                    }
                                case "SequenceExpression":
                                    switch(m.type){
                                        case "ReturnStatement":
                                            return false;
                                        case "ForStatement":
                                            return false;
                                        case "ExpressionStatement":
                                            return C !== "expression";
                                        case "ArrowFunctionExpression":
                                            return C !== "body";
                                        default:
                                            return true;
                                    }
                                case "YieldExpression":
                                    if (m.type === "UnaryExpression" || m.type === "AwaitExpression" || _2(m) || m.type === "TSNonNullExpression") return true;
                                case "AwaitExpression":
                                    switch(m.type){
                                        case "TaggedTemplateExpression":
                                        case "UnaryExpression":
                                        case "LogicalExpression":
                                        case "SpreadElement":
                                        case "SpreadProperty":
                                        case "TSAsExpression":
                                        case "TSSatisfiesExpression":
                                        case "TSNonNullExpression":
                                        case "BindExpression":
                                            return true;
                                        case "MemberExpression":
                                        case "OptionalMemberExpression":
                                            return C === "object";
                                        case "NewExpression":
                                        case "CallExpression":
                                        case "OptionalCallExpression":
                                            return C === "callee";
                                        case "ConditionalExpression":
                                            return C === "test";
                                        case "BinaryExpression":
                                            return !(!o.argument && m.operator === "|>");
                                        default:
                                            return false;
                                    }
                                case "TSConditionalType":
                                case "TSFunctionType":
                                case "TSConstructorType":
                                    if (C === "extendsType" && m.type === "TSConditionalType") {
                                        if (o.type === "TSConditionalType") return true;
                                        let { typeAnnotation: S } = o.returnType || o.typeAnnotation;
                                        if (S.type === "TSTypePredicate" && S.typeAnnotation && (S = S.typeAnnotation.typeAnnotation), S.type === "TSInferType" && S.typeParameter.constraint) return true;
                                    }
                                    if (C === "checkType" && m.type === "TSConditionalType") return true;
                                case "TSUnionType":
                                case "TSIntersectionType":
                                    if ((m.type === "TSUnionType" || m.type === "TSIntersectionType") && m.types.length > 1 && (!o.types || o.types.length > 1)) return true;
                                case "TSInferType":
                                    if (o.type === "TSInferType" && m.type === "TSRestType") return false;
                                case "TSTypeOperator":
                                    return m.type === "TSArrayType" || m.type === "TSOptionalType" || m.type === "TSRestType" || C === "objectType" && m.type === "TSIndexedAccessType" || m.type === "TSTypeOperator" || m.type === "TSTypeAnnotation" && D.getParentNode(1).type.startsWith("TSJSDoc");
                                case "TSTypeQuery":
                                    return C === "objectType" && m.type === "TSIndexedAccessType" || C === "elementType" && m.type === "TSArrayType";
                                case "TypeofTypeAnnotation":
                                    return C === "objectType" && (m.type === "IndexedAccessType" || m.type === "OptionalIndexedAccessType") || C === "elementType" && m.type === "ArrayTypeAnnotation";
                                case "ArrayTypeAnnotation":
                                    return m.type === "NullableTypeAnnotation";
                                case "IntersectionTypeAnnotation":
                                case "UnionTypeAnnotation":
                                    return m.type === "ArrayTypeAnnotation" || m.type === "NullableTypeAnnotation" || m.type === "IntersectionTypeAnnotation" || m.type === "UnionTypeAnnotation" || C === "objectType" && (m.type === "IndexedAccessType" || m.type === "OptionalIndexedAccessType");
                                case "NullableTypeAnnotation":
                                    return m.type === "ArrayTypeAnnotation" || C === "objectType" && (m.type === "IndexedAccessType" || m.type === "OptionalIndexedAccessType");
                                case "FunctionTypeAnnotation":
                                    {
                                        let S = m.type === "NullableTypeAnnotation" ? D.getParentNode(1) : m;
                                        return S.type === "UnionTypeAnnotation" || S.type === "IntersectionTypeAnnotation" || S.type === "ArrayTypeAnnotation" || C === "objectType" && (S.type === "IndexedAccessType" || S.type === "OptionalIndexedAccessType") || S.type === "NullableTypeAnnotation" || m.type === "FunctionTypeParam" && m.name === null && a2(o).some((b)=>b.typeAnnotation && b.typeAnnotation.type === "NullableTypeAnnotation");
                                    }
                                case "OptionalIndexedAccessType":
                                    return C === "objectType" && m.type === "IndexedAccessType";
                                case "StringLiteral":
                                case "NumericLiteral":
                                case "Literal":
                                    if (typeof o.value == "string" && m.type === "ExpressionStatement" && !m.directive) {
                                        let S = D.getParentNode(1);
                                        return S.type === "Program" || S.type === "BlockStatement";
                                    }
                                    return C === "object" && m.type === "MemberExpression" && typeof o.value == "number";
                                case "AssignmentExpression":
                                    {
                                        let S = D.getParentNode(1);
                                        return C === "body" && m.type === "ArrowFunctionExpression" ? true : C === "key" && (m.type === "ClassProperty" || m.type === "PropertyDefinition") && m.computed || (C === "init" || C === "update") && m.type === "ForStatement" ? false : m.type === "ExpressionStatement" ? o.left.type === "ObjectPattern" : !(C === "key" && m.type === "TSPropertySignature" || m.type === "AssignmentExpression" || m.type === "SequenceExpression" && S && S.type === "ForStatement" && (S.init === m || S.update === m) || C === "value" && m.type === "Property" && S && S.type === "ObjectPattern" && S.properties.includes(m) || m.type === "NGChainedExpression");
                                    }
                                case "ConditionalExpression":
                                    switch(m.type){
                                        case "TaggedTemplateExpression":
                                        case "UnaryExpression":
                                        case "SpreadElement":
                                        case "SpreadProperty":
                                        case "BinaryExpression":
                                        case "LogicalExpression":
                                        case "NGPipeExpression":
                                        case "ExportDefaultDeclaration":
                                        case "AwaitExpression":
                                        case "JSXSpreadAttribute":
                                        case "TSTypeAssertion":
                                        case "TypeCastExpression":
                                        case "TSAsExpression":
                                        case "TSSatisfiesExpression":
                                        case "TSNonNullExpression":
                                            return true;
                                        case "NewExpression":
                                        case "CallExpression":
                                        case "OptionalCallExpression":
                                            return C === "callee";
                                        case "ConditionalExpression":
                                            return C === "test";
                                        case "MemberExpression":
                                        case "OptionalMemberExpression":
                                            return C === "object";
                                        default:
                                            return false;
                                    }
                                case "FunctionExpression":
                                    switch(m.type){
                                        case "NewExpression":
                                        case "CallExpression":
                                        case "OptionalCallExpression":
                                            return C === "callee";
                                        case "TaggedTemplateExpression":
                                            return true;
                                        default:
                                            return false;
                                    }
                                case "ArrowFunctionExpression":
                                    switch(m.type){
                                        case "BinaryExpression":
                                            return m.operator !== "|>" || o.extra && o.extra.parenthesized;
                                        case "NewExpression":
                                        case "CallExpression":
                                        case "OptionalCallExpression":
                                            return C === "callee";
                                        case "MemberExpression":
                                        case "OptionalMemberExpression":
                                            return C === "object";
                                        case "TSAsExpression":
                                        case "TSSatisfiesExpression":
                                        case "TSNonNullExpression":
                                        case "BindExpression":
                                        case "TaggedTemplateExpression":
                                        case "UnaryExpression":
                                        case "LogicalExpression":
                                        case "AwaitExpression":
                                        case "TSTypeAssertion":
                                            return true;
                                        case "ConditionalExpression":
                                            return C === "test";
                                        default:
                                            return false;
                                    }
                                case "ClassExpression":
                                    if (s(o.decorators)) return true;
                                    switch(m.type){
                                        case "NewExpression":
                                            return C === "callee";
                                        default:
                                            return false;
                                    }
                                case "OptionalMemberExpression":
                                case "OptionalCallExpression":
                                    {
                                        let S = D.getParentNode(1);
                                        if (C === "object" && m.type === "MemberExpression" || C === "callee" && (m.type === "CallExpression" || m.type === "NewExpression") || m.type === "TSNonNullExpression" && S.type === "MemberExpression" && S.object === m) return true;
                                    }
                                case "CallExpression":
                                case "MemberExpression":
                                case "TaggedTemplateExpression":
                                case "TSNonNullExpression":
                                    if (C === "callee" && (m.type === "BindExpression" || m.type === "NewExpression")) {
                                        let S = o;
                                        for(; S;)switch(S.type){
                                            case "CallExpression":
                                            case "OptionalCallExpression":
                                                return true;
                                            case "MemberExpression":
                                            case "OptionalMemberExpression":
                                            case "BindExpression":
                                                S = S.object;
                                                break;
                                            case "TaggedTemplateExpression":
                                                S = S.tag;
                                                break;
                                            case "TSNonNullExpression":
                                                S = S.expression;
                                                break;
                                            default:
                                                return false;
                                        }
                                    }
                                    return false;
                                case "BindExpression":
                                    return C === "callee" && (m.type === "BindExpression" || m.type === "NewExpression") || C === "object" && f2(m);
                                case "NGPipeExpression":
                                    return !(m.type === "NGRoot" || m.type === "NGMicrosyntaxExpression" || m.type === "ObjectProperty" && !(o.extra && o.extra.parenthesized) || m.type === "ArrayExpression" || c(m) && m.arguments[C] === o || C === "right" && m.type === "NGPipeExpression" || C === "property" && m.type === "MemberExpression" || m.type === "AssignmentExpression");
                                case "JSXFragment":
                                case "JSXElement":
                                    return C === "callee" || C === "left" && m.type === "BinaryExpression" && m.operator === "<" || m.type !== "ArrayExpression" && m.type !== "ArrowFunctionExpression" && m.type !== "AssignmentExpression" && m.type !== "AssignmentPattern" && m.type !== "BinaryExpression" && m.type !== "NewExpression" && m.type !== "ConditionalExpression" && m.type !== "ExpressionStatement" && m.type !== "JsExpressionRoot" && m.type !== "JSXAttribute" && m.type !== "JSXElement" && m.type !== "JSXExpressionContainer" && m.type !== "JSXFragment" && m.type !== "LogicalExpression" && !c(m) && !F(m) && m.type !== "ReturnStatement" && m.type !== "ThrowStatement" && m.type !== "TypeCastExpression" && m.type !== "VariableDeclarator" && m.type !== "YieldExpression";
                                case "TypeAnnotation":
                                    return C === "returnType" && m.type === "ArrowFunctionExpression" && x(o);
                            }
                            return false;
                        }
                        function E(D) {
                            return D.type === "BlockStatement" || D.type === "BreakStatement" || D.type === "ClassBody" || D.type === "ClassDeclaration" || D.type === "ClassMethod" || D.type === "ClassProperty" || D.type === "PropertyDefinition" || D.type === "ClassPrivateProperty" || D.type === "ContinueStatement" || D.type === "DebuggerStatement" || D.type === "DeclareClass" || D.type === "DeclareExportAllDeclaration" || D.type === "DeclareExportDeclaration" || D.type === "DeclareFunction" || D.type === "DeclareInterface" || D.type === "DeclareModule" || D.type === "DeclareModuleExports" || D.type === "DeclareVariable" || D.type === "DoWhileStatement" || D.type === "EnumDeclaration" || D.type === "ExportAllDeclaration" || D.type === "ExportDefaultDeclaration" || D.type === "ExportNamedDeclaration" || D.type === "ExpressionStatement" || D.type === "ForInStatement" || D.type === "ForOfStatement" || D.type === "ForStatement" || D.type === "FunctionDeclaration" || D.type === "IfStatement" || D.type === "ImportDeclaration" || D.type === "InterfaceDeclaration" || D.type === "LabeledStatement" || D.type === "MethodDefinition" || D.type === "ReturnStatement" || D.type === "SwitchStatement" || D.type === "ThrowStatement" || D.type === "TryStatement" || D.type === "TSDeclareFunction" || D.type === "TSEnumDeclaration" || D.type === "TSImportEqualsDeclaration" || D.type === "TSInterfaceDeclaration" || D.type === "TSModuleDeclaration" || D.type === "TSNamespaceExportDeclaration" || D.type === "TypeAlias" || D.type === "VariableDeclaration" || D.type === "WhileStatement" || D.type === "WithStatement";
                        }
                        function N(D) {
                            let T = 0, m = D.getValue();
                            for(; m;){
                                let C = D.getParentNode(T++);
                                if (C && C.type === "ForStatement" && C.init === m) return true;
                                m = C;
                            }
                            return false;
                        }
                        function x(D) {
                            return l(D, (T)=>T.type === "ObjectTypeAnnotation" && l(T, (m)=>m.type === "FunctionTypeAnnotation" || void 0) || void 0);
                        }
                        function I(D) {
                            switch(D.type){
                                case "ObjectExpression":
                                    return true;
                                default:
                                    return false;
                            }
                        }
                        function P(D) {
                            let T = D.getValue(), m = D.getParentNode(), C = D.getName();
                            switch(m.type){
                                case "NGPipeExpression":
                                    if (typeof C == "number" && m.arguments[C] === T && m.arguments.length - 1 === C) return D.callParent(P);
                                    break;
                                case "ObjectProperty":
                                    if (C === "value") {
                                        let o = D.getParentNode(1);
                                        return t1(o.properties) === m;
                                    }
                                    break;
                                case "BinaryExpression":
                                case "LogicalExpression":
                                    if (C === "right") return D.callParent(P);
                                    break;
                                case "ConditionalExpression":
                                    if (C === "alternate") return D.callParent(P);
                                    break;
                                case "UnaryExpression":
                                    if (m.prefix) return D.callParent(P);
                                    break;
                            }
                            return false;
                        }
                        function $(D, T) {
                            let m = D.getValue(), C = D.getParentNode();
                            return m.type === "FunctionExpression" || m.type === "ClassExpression" ? C.type === "ExportDefaultDeclaration" || !w(D, T) : !i(m) || C.type !== "ExportDefaultDeclaration" && w(D, T) ? false : D.call((o)=>$(o, T), ...n(D, m));
                        }
                        r.exports = w;
                    }
                }), Fo = te({
                    "src/language-js/print-preprocess.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s, a2) {
                            switch(a2.parser){
                                case "json":
                                case "json5":
                                case "json-stringify":
                                case "__js_expression":
                                case "__vue_expression":
                                case "__vue_ts_expression":
                                    return Object.assign(Object.assign({}, s), {}, {
                                        type: a2.parser.startsWith("__") ? "JsExpressionRoot" : "JsonRoot",
                                        node: s,
                                        comments: [],
                                        rootMarker: a2.rootMarker
                                    });
                                default:
                                    return s;
                            }
                        }
                        r.exports = t1;
                    }
                }), pd = te({
                    "src/language-js/print/html-binding.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { join: t1, line: s, group: a2, softline: n, indent: u } } = qe();
                        function i(p, y, h) {
                            let g = p.getValue();
                            if (y.__onHtmlBindingRoot && p.getName() === null && y.__onHtmlBindingRoot(g, y), g.type === "File") {
                                if (y.__isVueForBindingLeft) return p.call((c)=>{
                                    let f2 = t1([
                                        ",",
                                        s
                                    ], c.map(h, "params")), { params: F } = c.getValue();
                                    return F.length === 1 ? f2 : [
                                        "(",
                                        u([
                                            n,
                                            a2(f2)
                                        ]),
                                        n,
                                        ")"
                                    ];
                                }, "program", "body", 0);
                                if (y.__isVueBindings) return p.call((c)=>t1([
                                        ",",
                                        s
                                    ], c.map(h, "params")), "program", "body", 0);
                            }
                        }
                        function l(p) {
                            switch(p.type){
                                case "MemberExpression":
                                    switch(p.property.type){
                                        case "Identifier":
                                        case "NumericLiteral":
                                        case "StringLiteral":
                                            return l(p.object);
                                    }
                                    return false;
                                case "Identifier":
                                    return true;
                                default:
                                    return false;
                            }
                        }
                        r.exports = {
                            isVueEventBindingExpression: l,
                            printHtmlBinding: i
                        };
                    }
                }), ru = te({
                    "src/language-js/print/binaryish.js" (e, r) {
                        "use strict";
                        ne();
                        var { printComments: t1 } = et(), { getLast: s } = Ue(), { builders: { join: a2, line: n, softline: u, group: i, indent: l, align: p, indentIfBreak: y }, utils: { cleanDoc: h, getDocParts: g, isConcat: c } } = qe(), { hasLeadingOwnLineComment: f2, isBinaryish: F, isJsxNode: _2, shouldFlatten: w, hasComment: E, CommentCheckFlags: N, isCallExpression: x, isMemberExpression: I, isObjectProperty: P, isEnabledHackPipeline: $ } = Ke(), D = 0;
                        function T(o, d, v) {
                            let S = o.getValue(), b = o.getParentNode(), B = o.getParentNode(1), k = S !== b.body && (b.type === "IfStatement" || b.type === "WhileStatement" || b.type === "SwitchStatement" || b.type === "DoWhileStatement"), M = $(d) && S.operator === "|>", R = m(o, v, d, false, k);
                            if (k) return R;
                            if (M) return i(R);
                            if (x(b) && b.callee === S || b.type === "UnaryExpression" || I(b) && !b.computed) return i([
                                l([
                                    u,
                                    ...R
                                ]),
                                u
                            ]);
                            let q = b.type === "ReturnStatement" || b.type === "ThrowStatement" || b.type === "JSXExpressionContainer" && B.type === "JSXAttribute" || S.operator !== "|" && b.type === "JsExpressionRoot" || S.type !== "NGPipeExpression" && (b.type === "NGRoot" && d.parser === "__ng_binding" || b.type === "NGMicrosyntaxExpression" && B.type === "NGMicrosyntax" && B.body.length === 1) || S === b.body && b.type === "ArrowFunctionExpression" || S !== b.body && b.type === "ForStatement" || b.type === "ConditionalExpression" && B.type !== "ReturnStatement" && B.type !== "ThrowStatement" && !x(B) || b.type === "TemplateLiteral", J = b.type === "AssignmentExpression" || b.type === "VariableDeclarator" || b.type === "ClassProperty" || b.type === "PropertyDefinition" || b.type === "TSAbstractPropertyDefinition" || b.type === "ClassPrivateProperty" || P(b), L = F(S.left) && w(S.operator, S.left.operator);
                            if (q || C(S) && !L || !C(S) && J) return i(R);
                            if (R.length === 0) return "";
                            let Q = _2(S.right), V = R.findIndex((W)=>typeof W != "string" && !Array.isArray(W) && W.type === "group"), j = R.slice(0, V === -1 ? 1 : V + 1), Y = R.slice(j.length, Q ? -1 : void 0), ie = Symbol("logicalChain-" + ++D), ee = i([
                                ...j,
                                l(Y)
                            ], {
                                id: ie
                            });
                            if (!Q) return ee;
                            let ce = s(R);
                            return i([
                                ee,
                                y(ce, {
                                    groupId: ie
                                })
                            ]);
                        }
                        function m(o, d, v, S, b) {
                            let B = o.getValue();
                            if (!F(B)) return [
                                i(d())
                            ];
                            let k = [];
                            w(B.operator, B.left.operator) ? k = o.call((Y)=>m(Y, d, v, true, b), "left") : k.push(i(d("left")));
                            let M = C(B), R = (B.operator === "|>" || B.type === "NGPipeExpression" || B.operator === "|" && v.parser === "__vue_expression") && !f2(v.originalText, B.right), q = B.type === "NGPipeExpression" ? "|" : B.operator, J = B.type === "NGPipeExpression" && B.arguments.length > 0 ? i(l([
                                n,
                                ": ",
                                a2([
                                    n,
                                    ": "
                                ], o.map(d, "arguments").map((Y)=>p(2, i(Y))))
                            ])) : "", L;
                            if (M) L = [
                                q,
                                " ",
                                d("right"),
                                J
                            ];
                            else {
                                let ie = $(v) && q === "|>" ? o.call((ee)=>m(ee, d, v, true, b), "right") : d("right");
                                L = [
                                    R ? n : "",
                                    q,
                                    R ? " " : n,
                                    ie,
                                    J
                                ];
                            }
                            let Q = o.getParentNode(), V = E(B.left, N.Trailing | N.Line), j = V || !(b && B.type === "LogicalExpression") && Q.type !== B.type && B.left.type !== B.type && B.right.type !== B.type;
                            if (k.push(R ? "" : " ", j ? i(L, {
                                shouldBreak: V
                            }) : L), S && E(B)) {
                                let Y = h(t1(o, k, v));
                                return c(Y) || Y.type === "fill" ? g(Y) : [
                                    Y
                                ];
                            }
                            return k;
                        }
                        function C(o) {
                            return o.type !== "LogicalExpression" ? false : !!(o.right.type === "ObjectExpression" && o.right.properties.length > 0 || o.right.type === "ArrayExpression" && o.right.elements.length > 0 || _2(o.right));
                        }
                        r.exports = {
                            printBinaryishExpression: T,
                            shouldInlineLogicalExpression: C
                        };
                    }
                }), fd = te({
                    "src/language-js/print/angular.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { join: t1, line: s, group: a2 } } = qe(), { hasNode: n, hasComment: u, getComments: i } = Ke(), { printBinaryishExpression: l } = ru();
                        function p(g, c, f2) {
                            let F = g.getValue();
                            if (F.type.startsWith("NG")) switch(F.type){
                                case "NGRoot":
                                    return [
                                        f2("node"),
                                        u(F.node) ? " //" + i(F.node)[0].value.trimEnd() : ""
                                    ];
                                case "NGPipeExpression":
                                    return l(g, c, f2);
                                case "NGChainedExpression":
                                    return a2(t1([
                                        ";",
                                        s
                                    ], g.map((_2)=>h(_2) ? f2() : [
                                            "(",
                                            f2(),
                                            ")"
                                        ], "expressions")));
                                case "NGEmptyExpression":
                                    return "";
                                case "NGQuotedExpression":
                                    return [
                                        F.prefix,
                                        ": ",
                                        F.value.trim()
                                    ];
                                case "NGMicrosyntax":
                                    return g.map((_2, w)=>[
                                            w === 0 ? "" : y(_2.getValue(), w, F) ? " " : [
                                                ";",
                                                s
                                            ],
                                            f2()
                                        ], "body");
                                case "NGMicrosyntaxKey":
                                    return /^[$_a-z][\w$]*(?:-[$_a-z][\w$])*$/i.test(F.name) ? F.name : JSON.stringify(F.name);
                                case "NGMicrosyntaxExpression":
                                    return [
                                        f2("expression"),
                                        F.alias === null ? "" : [
                                            " as ",
                                            f2("alias")
                                        ]
                                    ];
                                case "NGMicrosyntaxKeyedExpression":
                                    {
                                        let _2 = g.getName(), w = g.getParentNode(), E = y(F, _2, w) || (_2 === 1 && (F.key.name === "then" || F.key.name === "else") || _2 === 2 && F.key.name === "else" && w.body[_2 - 1].type === "NGMicrosyntaxKeyedExpression" && w.body[_2 - 1].key.name === "then") && w.body[0].type === "NGMicrosyntaxExpression";
                                        return [
                                            f2("key"),
                                            E ? " " : ": ",
                                            f2("expression")
                                        ];
                                    }
                                case "NGMicrosyntaxLet":
                                    return [
                                        "let ",
                                        f2("key"),
                                        F.value === null ? "" : [
                                            " = ",
                                            f2("value")
                                        ]
                                    ];
                                case "NGMicrosyntaxAs":
                                    return [
                                        f2("key"),
                                        " as ",
                                        f2("alias")
                                    ];
                                default:
                                    throw new Error(`Unknown Angular node type: ${JSON.stringify(F.type)}.`);
                            }
                        }
                        function y(g, c, f2) {
                            return g.type === "NGMicrosyntaxKeyedExpression" && g.key.name === "of" && c === 1 && f2.body[0].type === "NGMicrosyntaxLet" && f2.body[0].value === null;
                        }
                        function h(g) {
                            return n(g.getValue(), (c)=>{
                                switch(c.type){
                                    case void 0:
                                        return false;
                                    case "CallExpression":
                                    case "OptionalCallExpression":
                                    case "AssignmentExpression":
                                        return true;
                                }
                            });
                        }
                        r.exports = {
                            printAngular: p
                        };
                    }
                }), Dd = te({
                    "src/language-js/print/jsx.js" (e, r) {
                        "use strict";
                        ne();
                        var { printComments: t1, printDanglingComments: s, printCommentsSeparately: a2 } = et(), { builders: { line: n, hardline: u, softline: i, group: l, indent: p, conditionalGroup: y, fill: h, ifBreak: g, lineSuffixBoundary: c, join: f2 }, utils: { willBreak: F } } = qe(), { getLast: _2, getPreferredQuote: w } = Ue(), { isJsxNode: E, rawText: N, isCallExpression: x, isStringLiteral: I, isBinaryish: P, hasComment: $, CommentCheckFlags: D, hasNodeIgnoreComment: T } = Ke(), m = qt(), { willPrintOwnComments: C } = Eo(), o = (U)=>U === "" || U === n || U === u || U === i;
                        function d(U, Z, se) {
                            let fe = U.getValue();
                            if (fe.type === "JSXElement" && de(fe)) return [
                                se("openingElement"),
                                se("closingElement")
                            ];
                            let ge = fe.type === "JSXElement" ? se("openingElement") : se("openingFragment"), he = fe.type === "JSXElement" ? se("closingElement") : se("closingFragment");
                            if (fe.children.length === 1 && fe.children[0].type === "JSXExpressionContainer" && (fe.children[0].expression.type === "TemplateLiteral" || fe.children[0].expression.type === "TaggedTemplateExpression")) return [
                                ge,
                                ...U.map(se, "children"),
                                he
                            ];
                            fe.children = fe.children.map((A2)=>Fe(A2) ? {
                                    type: "JSXText",
                                    value: " ",
                                    raw: " "
                                } : A2);
                            let we = fe.children.some(E), ke = fe.children.filter((A2)=>A2.type === "JSXExpressionContainer").length > 1, Re = fe.type === "JSXElement" && fe.openingElement.attributes.length > 1, Ne = F(ge) || we || Re || ke, Pe = U.getParentNode().rootMarker === "mdx", oe = Z.singleQuote ? "{' '}" : '{" "}', H = Pe ? " " : g([
                                oe,
                                i
                            ], " "), pe = fe.openingElement && fe.openingElement.name && fe.openingElement.name.name === "fbt", X = v(U, Z, se, H, pe), le = fe.children.some((A2)=>ue(A2));
                            for(let A2 = X.length - 2; A2 >= 0; A2--){
                                let G = X[A2] === "" && X[A2 + 1] === "", re = X[A2] === u && X[A2 + 1] === "" && X[A2 + 2] === u, ye = (X[A2] === i || X[A2] === u) && X[A2 + 1] === "" && X[A2 + 2] === H, Ce = X[A2] === H && X[A2 + 1] === "" && (X[A2 + 2] === i || X[A2 + 2] === u), Be = X[A2] === H && X[A2 + 1] === "" && X[A2 + 2] === H, ve = X[A2] === i && X[A2 + 1] === "" && X[A2 + 2] === u || X[A2] === u && X[A2 + 1] === "" && X[A2 + 2] === i;
                                re && le || G || ye || Be || ve ? X.splice(A2, 2) : Ce && X.splice(A2 + 1, 2);
                            }
                            for(; X.length > 0 && o(_2(X));)X.pop();
                            for(; X.length > 1 && o(X[0]) && o(X[1]);)X.shift(), X.shift();
                            let Ae = [];
                            for (let [A2, G] of X.entries()){
                                if (G === H) {
                                    if (A2 === 1 && X[A2 - 1] === "") {
                                        if (X.length === 2) {
                                            Ae.push(oe);
                                            continue;
                                        }
                                        Ae.push([
                                            oe,
                                            u
                                        ]);
                                        continue;
                                    } else if (A2 === X.length - 1) {
                                        Ae.push(oe);
                                        continue;
                                    } else if (X[A2 - 1] === "" && X[A2 - 2] === u) {
                                        Ae.push(oe);
                                        continue;
                                    }
                                }
                                Ae.push(G), F(G) && (Ne = true);
                            }
                            let Ee = le ? h(Ae) : l(Ae, {
                                shouldBreak: true
                            });
                            if (Pe) return Ee;
                            let De = l([
                                ge,
                                p([
                                    u,
                                    Ee
                                ]),
                                u,
                                he
                            ]);
                            return Ne ? De : y([
                                l([
                                    ge,
                                    ...X,
                                    he
                                ]),
                                De
                            ]);
                        }
                        function v(U, Z, se, fe, ge) {
                            let he = [];
                            return U.each((we, ke, Re)=>{
                                let Ne = we.getValue();
                                if (Ne.type === "JSXText") {
                                    let Pe = N(Ne);
                                    if (ue(Ne)) {
                                        let oe = Pe.split(ce);
                                        if (oe[0] === "") {
                                            if (he.push(""), oe.shift(), /\n/.test(oe[0])) {
                                                let pe = Re[ke + 1];
                                                he.push(b(ge, oe[1], Ne, pe));
                                            } else he.push(fe);
                                            oe.shift();
                                        }
                                        let H;
                                        if (_2(oe) === "" && (oe.pop(), H = oe.pop()), oe.length === 0) return;
                                        for (let [pe, X] of oe.entries())pe % 2 === 1 ? he.push(n) : he.push(X);
                                        if (H !== void 0) if (/\n/.test(H)) {
                                            let pe = Re[ke + 1];
                                            he.push(b(ge, _2(he), Ne, pe));
                                        } else he.push(fe);
                                        else {
                                            let pe = Re[ke + 1];
                                            he.push(S(ge, _2(he), Ne, pe));
                                        }
                                    } else /\n/.test(Pe) ? Pe.match(/\n/g).length > 1 && he.push("", u) : he.push("", fe);
                                } else {
                                    let Pe = se();
                                    he.push(Pe);
                                    let oe = Re[ke + 1];
                                    if (oe && ue(oe)) {
                                        let pe = K(N(oe)).split(ce)[0];
                                        he.push(S(ge, pe, Ne, oe));
                                    } else he.push(u);
                                }
                            }, "children"), he;
                        }
                        function S(U, Z, se, fe) {
                            return U ? "" : se.type === "JSXElement" && !se.closingElement || fe && fe.type === "JSXElement" && !fe.closingElement ? Z.length === 1 ? i : u : i;
                        }
                        function b(U, Z, se, fe) {
                            return U ? u : Z.length === 1 ? se.type === "JSXElement" && !se.closingElement || fe && fe.type === "JSXElement" && !fe.closingElement ? u : i : u;
                        }
                        function B(U, Z, se) {
                            let fe = U.getParentNode();
                            if (!fe || ({
                                ArrayExpression: true,
                                JSXAttribute: true,
                                JSXElement: true,
                                JSXExpressionContainer: true,
                                JSXFragment: true,
                                ExpressionStatement: true,
                                CallExpression: true,
                                OptionalCallExpression: true,
                                ConditionalExpression: true,
                                JsExpressionRoot: true
                            })[fe.type]) return Z;
                            let he = U.match(void 0, (ke)=>ke.type === "ArrowFunctionExpression", x, (ke)=>ke.type === "JSXExpressionContainer"), we = m(U, se);
                            return l([
                                we ? "" : g("("),
                                p([
                                    i,
                                    Z
                                ]),
                                i,
                                we ? "" : g(")")
                            ], {
                                shouldBreak: he
                            });
                        }
                        function k(U, Z, se) {
                            let fe = U.getValue(), ge = [];
                            if (ge.push(se("name")), fe.value) {
                                let he;
                                if (I(fe.value)) {
                                    let ke = N(fe.value).slice(1, -1).replace(/&apos;/g, "'").replace(/&quot;/g, '"'), { escaped: Re, quote: Ne, regex: Pe } = w(ke, Z.jsxSingleQuote ? "'" : '"');
                                    ke = ke.replace(Pe, Re);
                                    let { leading: oe, trailing: H } = U.call(()=>a2(U, Z), "value");
                                    he = [
                                        oe,
                                        Ne,
                                        ke,
                                        Ne,
                                        H
                                    ];
                                } else he = se("value");
                                ge.push("=", he);
                            }
                            return ge;
                        }
                        function M(U, Z, se) {
                            let fe = U.getValue(), ge = (he, we)=>he.type === "JSXEmptyExpression" || !$(he) && (he.type === "ArrayExpression" || he.type === "ObjectExpression" || he.type === "ArrowFunctionExpression" || he.type === "AwaitExpression" && (ge(he.argument, he) || he.argument.type === "JSXElement") || x(he) || he.type === "FunctionExpression" || he.type === "TemplateLiteral" || he.type === "TaggedTemplateExpression" || he.type === "DoExpression" || E(we) && (he.type === "ConditionalExpression" || P(he)));
                            return ge(fe.expression, U.getParentNode(0)) ? l([
                                "{",
                                se("expression"),
                                c,
                                "}"
                            ]) : l([
                                "{",
                                p([
                                    i,
                                    se("expression")
                                ]),
                                i,
                                c,
                                "}"
                            ]);
                        }
                        function R(U, Z, se) {
                            let fe = U.getValue(), ge = fe.name && $(fe.name) || fe.typeParameters && $(fe.typeParameters);
                            if (fe.selfClosing && fe.attributes.length === 0 && !ge) return [
                                "<",
                                se("name"),
                                se("typeParameters"),
                                " />"
                            ];
                            if (fe.attributes && fe.attributes.length === 1 && fe.attributes[0].value && I(fe.attributes[0].value) && !fe.attributes[0].value.value.includes(`
`) && !ge && !$(fe.attributes[0])) return l([
                                "<",
                                se("name"),
                                se("typeParameters"),
                                " ",
                                ...U.map(se, "attributes"),
                                fe.selfClosing ? " />" : ">"
                            ]);
                            let he = fe.attributes && fe.attributes.some((ke)=>ke.value && I(ke.value) && ke.value.value.includes(`
`)), we = Z.singleAttributePerLine && fe.attributes.length > 1 ? u : n;
                            return l([
                                "<",
                                se("name"),
                                se("typeParameters"),
                                p(U.map(()=>[
                                        we,
                                        se()
                                    ], "attributes")),
                                ...q(fe, Z, ge)
                            ], {
                                shouldBreak: he
                            });
                        }
                        function q(U, Z, se) {
                            return U.selfClosing ? [
                                n,
                                "/>"
                            ] : J(U, Z, se) ? [
                                ">"
                            ] : [
                                i,
                                ">"
                            ];
                        }
                        function J(U, Z, se) {
                            let fe = U.attributes.length > 0 && $(_2(U.attributes), D.Trailing);
                            return U.attributes.length === 0 && !se || (Z.bracketSameLine || Z.jsxBracketSameLine) && (!se || U.attributes.length > 0) && !fe;
                        }
                        function L(U, Z, se) {
                            let fe = U.getValue(), ge = [];
                            ge.push("</");
                            let he = se("name");
                            return $(fe.name, D.Leading | D.Line) ? ge.push(p([
                                u,
                                he
                            ]), u) : $(fe.name, D.Leading | D.Block) ? ge.push(" ", he) : ge.push(he), ge.push(">"), ge;
                        }
                        function Q(U, Z) {
                            let se = U.getValue(), fe = $(se), ge = $(se, D.Line), he = se.type === "JSXOpeningFragment";
                            return [
                                he ? "<" : "</",
                                p([
                                    ge ? u : fe && !he ? " " : "",
                                    s(U, Z, true)
                                ]),
                                ge ? u : "",
                                ">"
                            ];
                        }
                        function V(U, Z, se) {
                            let fe = t1(U, d(U, Z, se), Z);
                            return B(U, fe, Z);
                        }
                        function j(U, Z) {
                            let se = U.getValue(), fe = $(se, D.Line);
                            return [
                                s(U, Z, !fe),
                                fe ? u : ""
                            ];
                        }
                        function Y(U, Z, se) {
                            let fe = U.getValue();
                            return [
                                "{",
                                U.call((ge)=>{
                                    let he = [
                                        "...",
                                        se()
                                    ], we = ge.getValue();
                                    return !$(we) || !C(ge) ? he : [
                                        p([
                                            i,
                                            t1(ge, he, Z)
                                        ]),
                                        i
                                    ];
                                }, fe.type === "JSXSpreadAttribute" ? "argument" : "expression"),
                                "}"
                            ];
                        }
                        function ie(U, Z, se) {
                            let fe = U.getValue();
                            if (fe.type.startsWith("JSX")) switch(fe.type){
                                case "JSXAttribute":
                                    return k(U, Z, se);
                                case "JSXIdentifier":
                                    return String(fe.name);
                                case "JSXNamespacedName":
                                    return f2(":", [
                                        se("namespace"),
                                        se("name")
                                    ]);
                                case "JSXMemberExpression":
                                    return f2(".", [
                                        se("object"),
                                        se("property")
                                    ]);
                                case "JSXSpreadAttribute":
                                    return Y(U, Z, se);
                                case "JSXSpreadChild":
                                    return Y(U, Z, se);
                                case "JSXExpressionContainer":
                                    return M(U, Z, se);
                                case "JSXFragment":
                                case "JSXElement":
                                    return V(U, Z, se);
                                case "JSXOpeningElement":
                                    return R(U, Z, se);
                                case "JSXClosingElement":
                                    return L(U, Z, se);
                                case "JSXOpeningFragment":
                                case "JSXClosingFragment":
                                    return Q(U, Z);
                                case "JSXEmptyExpression":
                                    return j(U, Z);
                                case "JSXText":
                                    throw new Error("JSXText should be handled by JSXElement");
                                default:
                                    throw new Error(`Unknown JSX node type: ${JSON.stringify(fe.type)}.`);
                            }
                        }
                        var ee = ` 
\r	`, ce = new RegExp("([" + ee + "]+)"), W = new RegExp("[^" + ee + "]"), K = (U)=>U.replace(new RegExp("(?:^" + ce.source + "|" + ce.source + "$)"), "");
                        function de(U) {
                            if (U.children.length === 0) return true;
                            if (U.children.length > 1) return false;
                            let Z = U.children[0];
                            return Z.type === "JSXText" && !ue(Z);
                        }
                        function ue(U) {
                            return U.type === "JSXText" && (W.test(N(U)) || !/\n/.test(N(U)));
                        }
                        function Fe(U) {
                            return U.type === "JSXExpressionContainer" && I(U.expression) && U.expression.value === " " && !$(U.expression);
                        }
                        function z(U) {
                            let Z = U.getValue(), se = U.getParentNode();
                            if (!se || !Z || !E(Z) || !E(se)) return false;
                            let fe = se.children.indexOf(Z), ge = null;
                            for(let he = fe; he > 0; he--){
                                let we = se.children[he - 1];
                                if (!(we.type === "JSXText" && !ue(we))) {
                                    ge = we;
                                    break;
                                }
                            }
                            return ge && ge.type === "JSXExpressionContainer" && ge.expression.type === "JSXEmptyExpression" && T(ge.expression);
                        }
                        r.exports = {
                            hasJsxIgnoreComment: z,
                            printJsx: ie
                        };
                    }
                }), ct = te({
                    "src/language-js/print/misc.js" (e, r) {
                        "use strict";
                        ne();
                        var { isNonEmptyArray: t1 } = Ue(), { builders: { indent: s, join: a2, line: n } } = qe(), { isFlowAnnotationComment: u } = Ke();
                        function i(_2) {
                            let w = _2.getValue();
                            return !w.optional || w.type === "Identifier" && w === _2.getParentNode().key ? "" : w.type === "OptionalCallExpression" || w.type === "OptionalMemberExpression" && w.computed ? "?." : "?";
                        }
                        function l(_2) {
                            return _2.getValue().definite || _2.match(void 0, (w, E)=>E === "id" && w.type === "VariableDeclarator" && w.definite) ? "!" : "";
                        }
                        function p(_2, w, E) {
                            let N = _2.getValue();
                            return N.typeArguments ? E("typeArguments") : N.typeParameters ? E("typeParameters") : "";
                        }
                        function y(_2, w, E) {
                            let N = _2.getValue();
                            if (!N.typeAnnotation) return "";
                            let x = _2.getParentNode(), I = x.type === "DeclareFunction" && x.id === N;
                            return u(w.originalText, N.typeAnnotation) ? [
                                " /*: ",
                                E("typeAnnotation"),
                                " */"
                            ] : [
                                I ? "" : ": ",
                                E("typeAnnotation")
                            ];
                        }
                        function h(_2, w, E) {
                            return [
                                "::",
                                E("callee")
                            ];
                        }
                        function g(_2, w, E) {
                            let N = _2.getValue();
                            return t1(N.modifiers) ? [
                                a2(" ", _2.map(E, "modifiers")),
                                " "
                            ] : "";
                        }
                        function c(_2, w, E) {
                            return _2.type === "EmptyStatement" ? ";" : _2.type === "BlockStatement" || E ? [
                                " ",
                                w
                            ] : s([
                                n,
                                w
                            ]);
                        }
                        function f2(_2, w, E) {
                            return [
                                "...",
                                E("argument"),
                                y(_2, w, E)
                            ];
                        }
                        function F(_2, w) {
                            let E = _2.slice(1, -1);
                            if (E.includes('"') || E.includes("'")) return _2;
                            let N = w.singleQuote ? "'" : '"';
                            return N + E + N;
                        }
                        r.exports = {
                            printOptionalToken: i,
                            printDefiniteToken: l,
                            printFunctionTypeParameters: p,
                            printBindExpressionCallee: h,
                            printTypeScriptModifiers: g,
                            printTypeAnnotation: y,
                            printRestSpread: f2,
                            adjustClause: c,
                            printDirective: F
                        };
                    }
                }), er = te({
                    "src/language-js/print/array.js" (e, r) {
                        "use strict";
                        ne();
                        var { printDanglingComments: t1 } = et(), { builders: { line: s, softline: a2, hardline: n, group: u, indent: i, ifBreak: l, fill: p } } = qe(), { getLast: y, hasNewline: h } = Ue(), { shouldPrintComma: g, hasComment: c, CommentCheckFlags: f2, isNextLineEmpty: F, isNumericLiteral: _2, isSignedNumericLiteral: w } = Ke(), { locStart: E } = ut(), { printOptionalToken: N, printTypeAnnotation: x } = ct();
                        function I(T, m, C) {
                            let o = T.getValue(), d = [], v = o.type === "TupleExpression" ? "#[" : "[", S = "]";
                            if (o.elements.length === 0) c(o, f2.Dangling) ? d.push(u([
                                v,
                                t1(T, m),
                                a2,
                                S
                            ])) : d.push(v, S);
                            else {
                                let b = y(o.elements), B = !(b && b.type === "RestElement"), k = b === null, M = Symbol("array"), R = !m.__inJestEach && o.elements.length > 1 && o.elements.every((L, Q, V)=>{
                                    let j = L && L.type;
                                    if (j !== "ArrayExpression" && j !== "ObjectExpression") return false;
                                    let Y = V[Q + 1];
                                    if (Y && j !== Y.type) return false;
                                    let ie = j === "ArrayExpression" ? "elements" : "properties";
                                    return L[ie] && L[ie].length > 1;
                                }), q = P(o, m), J = B ? k ? "," : g(m) ? q ? l(",", "", {
                                    groupId: M
                                }) : l(",") : "" : "";
                                d.push(u([
                                    v,
                                    i([
                                        a2,
                                        q ? D(T, m, C, J) : [
                                            $(T, m, "elements", C),
                                            J
                                        ],
                                        t1(T, m, true)
                                    ]),
                                    a2,
                                    S
                                ], {
                                    shouldBreak: R,
                                    id: M
                                }));
                            }
                            return d.push(N(T), x(T, m, C)), d;
                        }
                        function P(T, m) {
                            return T.elements.length > 1 && T.elements.every((C)=>C && (_2(C) || w(C) && !c(C.argument)) && !c(C, f2.Trailing | f2.Line, (o)=>!h(m.originalText, E(o), {
                                        backwards: true
                                    })));
                        }
                        function $(T, m, C, o) {
                            let d = [], v = [];
                            return T.each((S)=>{
                                d.push(v, u(o())), v = [
                                    ",",
                                    s
                                ], S.getValue() && F(S.getValue(), m) && v.push(a2);
                            }, C), d;
                        }
                        function D(T, m, C, o) {
                            let d = [];
                            return T.each((v, S, b)=>{
                                let B = S === b.length - 1;
                                d.push([
                                    C(),
                                    B ? o : ","
                                ]), B || d.push(F(v.getValue(), m) ? [
                                    n,
                                    n
                                ] : c(b[S + 1], f2.Leading | f2.Line) ? n : s);
                            }, "elements"), p(d);
                        }
                        r.exports = {
                            printArray: I,
                            printArrayItems: $,
                            isConciselyPrintedArray: P
                        };
                    }
                }), Ao = te({
                    "src/language-js/print/call-arguments.js" (e, r) {
                        "use strict";
                        ne();
                        var { printDanglingComments: t1 } = et(), { getLast: s, getPenultimate: a2 } = Ue(), { getFunctionParameters: n, hasComment: u, CommentCheckFlags: i, isFunctionCompositionArgs: l, isJsxNode: p, isLongCurriedCallExpression: y, shouldPrintComma: h, getCallArguments: g, iterateCallArgumentsPath: c, isNextLineEmpty: f2, isCallExpression: F, isStringLiteral: _2, isObjectProperty: w, isTSTypeExpression: E } = Ke(), { builders: { line: N, hardline: x, softline: I, group: P, indent: $, conditionalGroup: D, ifBreak: T, breakParent: m }, utils: { willBreak: C } } = qe(), { ArgExpansionBailout: o } = Qt(), { isConciselyPrintedArray: d } = er();
                        function v(q, J, L) {
                            let Q = q.getValue(), V = Q.type === "ImportExpression", j = g(Q);
                            if (j.length === 0) return [
                                "(",
                                t1(q, J, true),
                                ")"
                            ];
                            if (k(j)) return [
                                "(",
                                L([
                                    "arguments",
                                    0
                                ]),
                                ", ",
                                L([
                                    "arguments",
                                    1
                                ]),
                                ")"
                            ];
                            let Y = false, ie = false, ee = j.length - 1, ce = [];
                            c(q, (z, U)=>{
                                let Z = z.getNode(), se = [
                                    L()
                                ];
                                U === ee || (f2(Z, J) ? (U === 0 && (ie = true), Y = true, se.push(",", x, x)) : se.push(",", N)), ce.push(se);
                            });
                            let W = !(V || Q.callee && Q.callee.type === "Import") && h(J, "all") ? "," : "";
                            function K() {
                                return P([
                                    "(",
                                    $([
                                        N,
                                        ...ce
                                    ]),
                                    W,
                                    N,
                                    ")"
                                ], {
                                    shouldBreak: true
                                });
                            }
                            if (Y || q.getParentNode().type !== "Decorator" && l(j)) return K();
                            let de = B(j), ue = b(j, J);
                            if (de || ue) {
                                if (de ? ce.slice(1).some(C) : ce.slice(0, -1).some(C)) return K();
                                let z = [];
                                try {
                                    q.try(()=>{
                                        c(q, (U, Z)=>{
                                            de && Z === 0 && (z = [
                                                [
                                                    L([], {
                                                        expandFirstArg: true
                                                    }),
                                                    ce.length > 1 ? "," : "",
                                                    ie ? x : N,
                                                    ie ? x : ""
                                                ],
                                                ...ce.slice(1)
                                            ]), ue && Z === ee && (z = [
                                                ...ce.slice(0, -1),
                                                L([], {
                                                    expandLastArg: true
                                                })
                                            ]);
                                        });
                                    });
                                } catch (U) {
                                    if (U instanceof o) return K();
                                    throw U;
                                }
                                return [
                                    ce.some(C) ? m : "",
                                    D([
                                        [
                                            "(",
                                            ...z,
                                            ")"
                                        ],
                                        de ? [
                                            "(",
                                            P(z[0], {
                                                shouldBreak: true
                                            }),
                                            ...z.slice(1),
                                            ")"
                                        ] : [
                                            "(",
                                            ...ce.slice(0, -1),
                                            P(s(z), {
                                                shouldBreak: true
                                            }),
                                            ")"
                                        ],
                                        K()
                                    ])
                                ];
                            }
                            let Fe = [
                                "(",
                                $([
                                    I,
                                    ...ce
                                ]),
                                T(W),
                                I,
                                ")"
                            ];
                            return y(q) ? Fe : P(Fe, {
                                shouldBreak: ce.some(C) || Y
                            });
                        }
                        function S(q) {
                            let J = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
                            return q.type === "ObjectExpression" && (q.properties.length > 0 || u(q)) || q.type === "ArrayExpression" && (q.elements.length > 0 || u(q)) || q.type === "TSTypeAssertion" && S(q.expression) || E(q) && S(q.expression) || q.type === "FunctionExpression" || q.type === "ArrowFunctionExpression" && (!q.returnType || !q.returnType.typeAnnotation || q.returnType.typeAnnotation.type !== "TSTypeReference" || M(q.body)) && (q.body.type === "BlockStatement" || q.body.type === "ArrowFunctionExpression" && S(q.body, true) || q.body.type === "ObjectExpression" || q.body.type === "ArrayExpression" || !J && (F(q.body) || q.body.type === "ConditionalExpression") || p(q.body)) || q.type === "DoExpression" || q.type === "ModuleExpression";
                        }
                        function b(q, J) {
                            let L = s(q), Q = a2(q);
                            return !u(L, i.Leading) && !u(L, i.Trailing) && S(L) && (!Q || Q.type !== L.type) && (q.length !== 2 || Q.type !== "ArrowFunctionExpression" || L.type !== "ArrayExpression") && !(q.length > 1 && L.type === "ArrayExpression" && d(L, J));
                        }
                        function B(q) {
                            if (q.length !== 2) return false;
                            let [J, L] = q;
                            return J.type === "ModuleExpression" && R(L) ? true : !u(J) && (J.type === "FunctionExpression" || J.type === "ArrowFunctionExpression" && J.body.type === "BlockStatement") && L.type !== "FunctionExpression" && L.type !== "ArrowFunctionExpression" && L.type !== "ConditionalExpression" && !S(L);
                        }
                        function k(q) {
                            return q.length === 2 && q[0].type === "ArrowFunctionExpression" && n(q[0]).length === 0 && q[0].body.type === "BlockStatement" && q[1].type === "ArrayExpression" && !q.some((J)=>u(J));
                        }
                        function M(q) {
                            return q.type === "BlockStatement" && (q.body.some((J)=>J.type !== "EmptyStatement") || u(q, i.Dangling));
                        }
                        function R(q) {
                            return q.type === "ObjectExpression" && q.properties.length === 1 && w(q.properties[0]) && q.properties[0].key.type === "Identifier" && q.properties[0].key.name === "type" && _2(q.properties[0].value) && q.properties[0].value.value === "module";
                        }
                        r.exports = v;
                    }
                }), So = te({
                    "src/language-js/print/member.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { softline: t1, group: s, indent: a2, label: n } } = qe(), { isNumericLiteral: u, isMemberExpression: i, isCallExpression: l } = Ke(), { printOptionalToken: p } = ct();
                        function y(g, c, f2) {
                            let F = g.getValue(), _2 = g.getParentNode(), w, E = 0;
                            do w = g.getParentNode(E), E++;
                            while (w && (i(w) || w.type === "TSNonNullExpression"))
                            let N = f2("object"), x = h(g, c, f2), I = w && (w.type === "NewExpression" || w.type === "BindExpression" || w.type === "AssignmentExpression" && w.left.type !== "Identifier") || F.computed || F.object.type === "Identifier" && F.property.type === "Identifier" && !i(_2) || (_2.type === "AssignmentExpression" || _2.type === "VariableDeclarator") && (l(F.object) && F.object.arguments.length > 0 || F.object.type === "TSNonNullExpression" && l(F.object.expression) && F.object.expression.arguments.length > 0 || N.label === "member-chain");
                            return n(N.label === "member-chain" ? "member-chain" : "member", [
                                N,
                                I ? x : s(a2([
                                    t1,
                                    x
                                ]))
                            ]);
                        }
                        function h(g, c, f2) {
                            let F = f2("property"), _2 = g.getValue(), w = p(g);
                            return _2.computed ? !_2.property || u(_2.property) ? [
                                w,
                                "[",
                                F,
                                "]"
                            ] : s([
                                w,
                                "[",
                                a2([
                                    t1,
                                    F
                                ]),
                                t1,
                                "]"
                            ]) : [
                                w,
                                ".",
                                F
                            ];
                        }
                        r.exports = {
                            printMemberExpression: y,
                            printMemberLookup: h
                        };
                    }
                }), md = te({
                    "src/language-js/print/member-chain.js" (e, r) {
                        "use strict";
                        ne();
                        var { printComments: t1 } = et(), { getLast: s, isNextLineEmptyAfterIndex: a2, getNextNonSpaceNonCommentCharacterIndex: n } = Ue(), u = qt(), { isCallExpression: i, isMemberExpression: l, isFunctionOrArrowExpression: p, isLongCurriedCallExpression: y, isMemberish: h, isNumericLiteral: g, isSimpleCallArgument: c, hasComment: f2, CommentCheckFlags: F, isNextLineEmpty: _2 } = Ke(), { locEnd: w } = ut(), { builders: { join: E, hardline: N, group: x, indent: I, conditionalGroup: P, breakParent: $, label: D }, utils: { willBreak: T } } = qe(), m = Ao(), { printMemberLookup: C } = So(), { printOptionalToken: o, printFunctionTypeParameters: d, printBindExpressionCallee: v } = ct();
                        function S(b, B, k) {
                            let M = b.getParentNode(), R = !M || M.type === "ExpressionStatement", q = [];
                            function J(Ne) {
                                let { originalText: Pe } = B, oe = n(Pe, Ne, w);
                                return Pe.charAt(oe) === ")" ? oe !== false && a2(Pe, oe + 1) : _2(Ne, B);
                            }
                            function L(Ne) {
                                let Pe = Ne.getValue();
                                i(Pe) && (h(Pe.callee) || i(Pe.callee)) ? (q.unshift({
                                    node: Pe,
                                    printed: [
                                        t1(Ne, [
                                            o(Ne),
                                            d(Ne, B, k),
                                            m(Ne, B, k)
                                        ], B),
                                        J(Pe) ? N : ""
                                    ]
                                }), Ne.call((oe)=>L(oe), "callee")) : h(Pe) ? (q.unshift({
                                    node: Pe,
                                    needsParens: u(Ne, B),
                                    printed: t1(Ne, l(Pe) ? C(Ne, B, k) : v(Ne, B, k), B)
                                }), Ne.call((oe)=>L(oe), "object")) : Pe.type === "TSNonNullExpression" ? (q.unshift({
                                    node: Pe,
                                    printed: t1(Ne, "!", B)
                                }), Ne.call((oe)=>L(oe), "expression")) : q.unshift({
                                    node: Pe,
                                    printed: k()
                                });
                            }
                            let Q = b.getValue();
                            q.unshift({
                                node: Q,
                                printed: [
                                    o(b),
                                    d(b, B, k),
                                    m(b, B, k)
                                ]
                            }), Q.callee && b.call((Ne)=>L(Ne), "callee");
                            let V = [], j = [
                                q[0]
                            ], Y = 1;
                            for(; Y < q.length && (q[Y].node.type === "TSNonNullExpression" || i(q[Y].node) || l(q[Y].node) && q[Y].node.computed && g(q[Y].node.property)); ++Y)j.push(q[Y]);
                            if (!i(q[0].node)) for(; Y + 1 < q.length && h(q[Y].node) && h(q[Y + 1].node); ++Y)j.push(q[Y]);
                            V.push(j), j = [];
                            let ie = false;
                            for(; Y < q.length; ++Y){
                                if (ie && h(q[Y].node)) {
                                    if (q[Y].node.computed && g(q[Y].node.property)) {
                                        j.push(q[Y]);
                                        continue;
                                    }
                                    V.push(j), j = [], ie = false;
                                }
                                (i(q[Y].node) || q[Y].node.type === "ImportExpression") && (ie = true), j.push(q[Y]), f2(q[Y].node, F.Trailing) && (V.push(j), j = [], ie = false);
                            }
                            j.length > 0 && V.push(j);
                            function ee(Ne) {
                                return /^[A-Z]|^[$_]+$/.test(Ne);
                            }
                            function ce(Ne) {
                                return Ne.length <= B.tabWidth;
                            }
                            function W(Ne) {
                                let Pe = Ne[1].length > 0 && Ne[1][0].node.computed;
                                if (Ne[0].length === 1) {
                                    let H = Ne[0][0].node;
                                    return H.type === "ThisExpression" || H.type === "Identifier" && (ee(H.name) || R && ce(H.name) || Pe);
                                }
                                let oe = s(Ne[0]).node;
                                return l(oe) && oe.property.type === "Identifier" && (ee(oe.property.name) || Pe);
                            }
                            let K = V.length >= 2 && !f2(V[1][0].node) && W(V);
                            function de(Ne) {
                                let Pe = Ne.map((oe)=>oe.printed);
                                return Ne.length > 0 && s(Ne).needsParens ? [
                                    "(",
                                    ...Pe,
                                    ")"
                                ] : Pe;
                            }
                            function ue(Ne) {
                                return Ne.length === 0 ? "" : I(x([
                                    N,
                                    E(N, Ne.map(de))
                                ]));
                            }
                            let Fe = V.map(de), z = Fe, U = K ? 3 : 2, Z = V.flat(), se = Z.slice(1, -1).some((Ne)=>f2(Ne.node, F.Leading)) || Z.slice(0, -1).some((Ne)=>f2(Ne.node, F.Trailing)) || V[U] && f2(V[U][0].node, F.Leading);
                            if (V.length <= U && !se) return y(b) ? z : x(z);
                            let fe = s(V[K ? 1 : 0]).node, ge = !i(fe) && J(fe), he = [
                                de(V[0]),
                                K ? V.slice(1, 2).map(de) : "",
                                ge ? N : "",
                                ue(V.slice(K ? 2 : 1))
                            ], we = q.map((Ne)=>{
                                let { node: Pe } = Ne;
                                return Pe;
                            }).filter(i);
                            function ke() {
                                let Ne = s(s(V)).node, Pe = s(Fe);
                                return i(Ne) && T(Pe) && we.slice(0, -1).some((oe)=>oe.arguments.some(p));
                            }
                            let Re;
                            return se || we.length > 2 && we.some((Ne)=>!Ne.arguments.every((Pe)=>c(Pe, 0))) || Fe.slice(0, -1).some(T) || ke() ? Re = x(he) : Re = [
                                T(z) || ge ? $ : "",
                                P([
                                    z,
                                    he
                                ])
                            ], D("member-chain", Re);
                        }
                        r.exports = S;
                    }
                }), xo = te({
                    "src/language-js/print/call-expression.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { join: t1, group: s } } = qe(), a2 = qt(), { getCallArguments: n, hasFlowAnnotationComment: u, isCallExpression: i, isMemberish: l, isStringLiteral: p, isTemplateOnItsOwnLine: y, isTestCall: h, iterateCallArgumentsPath: g } = Ke(), c = md(), f2 = Ao(), { printOptionalToken: F, printFunctionTypeParameters: _2 } = ct();
                        function w(N, x, I) {
                            let P = N.getValue(), $ = N.getParentNode(), D = P.type === "NewExpression", T = P.type === "ImportExpression", m = F(N), C = n(P);
                            if (C.length > 0 && (!T && !D && E(P, $) || C.length === 1 && y(C[0], x.originalText) || !D && h(P, $))) {
                                let v = [];
                                return g(N, ()=>{
                                    v.push(I());
                                }), [
                                    D ? "new " : "",
                                    I("callee"),
                                    m,
                                    _2(N, x, I),
                                    "(",
                                    t1(", ", v),
                                    ")"
                                ];
                            }
                            let o = (x.parser === "babel" || x.parser === "babel-flow") && P.callee && P.callee.type === "Identifier" && u(P.callee.trailingComments);
                            if (o && (P.callee.trailingComments[0].printed = true), !T && !D && l(P.callee) && !N.call((v)=>a2(v, x), "callee")) return c(N, x, I);
                            let d = [
                                D ? "new " : "",
                                T ? "import" : I("callee"),
                                m,
                                o ? `/*:: ${P.callee.trailingComments[0].value.slice(2).trim()} */` : "",
                                _2(N, x, I),
                                f2(N, x, I)
                            ];
                            return T || i(P.callee) ? s(d) : d;
                        }
                        function E(N, x) {
                            if (N.callee.type !== "Identifier") return false;
                            if (N.callee.name === "require") return true;
                            if (N.callee.name === "define") {
                                let I = n(N);
                                return x.type === "ExpressionStatement" && (I.length === 1 || I.length === 2 && I[0].type === "ArrayExpression" || I.length === 3 && p(I[0]) && I[1].type === "ArrayExpression");
                            }
                            return false;
                        }
                        r.exports = {
                            printCallExpression: w
                        };
                    }
                }), tr = te({
                    "src/language-js/print/assignment.js" (e, r) {
                        "use strict";
                        ne();
                        var { isNonEmptyArray: t1, getStringWidth: s } = Ue(), { builders: { line: a2, group: n, indent: u, indentIfBreak: i, lineSuffixBoundary: l }, utils: { cleanDoc: p, willBreak: y, canBreak: h } } = qe(), { hasLeadingOwnLineComment: g, isBinaryish: c, isStringLiteral: f2, isLiteral: F, isNumericLiteral: _2, isCallExpression: w, isMemberExpression: E, getCallArguments: N, rawText: x, hasComment: I, isSignedNumericLiteral: P, isObjectProperty: $ } = Ke(), { shouldInlineLogicalExpression: D } = ru(), { printCallExpression: T } = xo();
                        function m(W, K, de, ue, Fe, z) {
                            let U = d(W, K, de, ue, z), Z = de(z, {
                                assignmentLayout: U
                            });
                            switch(U){
                                case "break-after-operator":
                                    return n([
                                        n(ue),
                                        Fe,
                                        n(u([
                                            a2,
                                            Z
                                        ]))
                                    ]);
                                case "never-break-after-operator":
                                    return n([
                                        n(ue),
                                        Fe,
                                        " ",
                                        Z
                                    ]);
                                case "fluid":
                                    {
                                        let se = Symbol("assignment");
                                        return n([
                                            n(ue),
                                            Fe,
                                            n(u(a2), {
                                                id: se
                                            }),
                                            l,
                                            i(Z, {
                                                groupId: se
                                            })
                                        ]);
                                    }
                                case "break-lhs":
                                    return n([
                                        ue,
                                        Fe,
                                        " ",
                                        n(Z)
                                    ]);
                                case "chain":
                                    return [
                                        n(ue),
                                        Fe,
                                        a2,
                                        Z
                                    ];
                                case "chain-tail":
                                    return [
                                        n(ue),
                                        Fe,
                                        u([
                                            a2,
                                            Z
                                        ])
                                    ];
                                case "chain-tail-arrow-chain":
                                    return [
                                        n(ue),
                                        Fe,
                                        Z
                                    ];
                                case "only-left":
                                    return ue;
                            }
                        }
                        function C(W, K, de) {
                            let ue = W.getValue();
                            return m(W, K, de, de("left"), [
                                " ",
                                ue.operator
                            ], "right");
                        }
                        function o(W, K, de) {
                            return m(W, K, de, de("id"), " =", "init");
                        }
                        function d(W, K, de, ue, Fe) {
                            let z = W.getValue(), U = z[Fe];
                            if (!U) return "only-left";
                            let Z = !b(U);
                            if (W.match(b, B, (he)=>!Z || he.type !== "ExpressionStatement" && he.type !== "VariableDeclaration")) return Z ? U.type === "ArrowFunctionExpression" && U.body.type === "ArrowFunctionExpression" ? "chain-tail-arrow-chain" : "chain-tail" : "chain";
                            if (!Z && b(U.right) || g(K.originalText, U)) return "break-after-operator";
                            if (U.type === "CallExpression" && U.callee.name === "require" || K.parser === "json5" || K.parser === "json") return "never-break-after-operator";
                            if (S(z) || k(z) || q(z) || J(z) && h(ue)) return "break-lhs";
                            let ge = ie(z, ue, K);
                            return W.call(()=>v(W, K, de, ge), Fe) ? "break-after-operator" : ge || U.type === "TemplateLiteral" || U.type === "TaggedTemplateExpression" || U.type === "BooleanLiteral" || _2(U) || U.type === "ClassExpression" ? "never-break-after-operator" : "fluid";
                        }
                        function v(W, K, de, ue) {
                            let Fe = W.getValue();
                            if (c(Fe) && !D(Fe)) return true;
                            switch(Fe.type){
                                case "StringLiteralTypeAnnotation":
                                case "SequenceExpression":
                                    return true;
                                case "ConditionalExpression":
                                    {
                                        let { test: Z } = Fe;
                                        return c(Z) && !D(Z);
                                    }
                                case "ClassExpression":
                                    return t1(Fe.decorators);
                            }
                            if (ue) return false;
                            let z = Fe, U = [];
                            for(;;)if (z.type === "UnaryExpression") z = z.argument, U.push("argument");
                            else if (z.type === "TSNonNullExpression") z = z.expression, U.push("expression");
                            else break;
                            return !!(f2(z) || W.call(()=>V(W, K, de), ...U));
                        }
                        function S(W) {
                            if (B(W)) {
                                let K = W.left || W.id;
                                return K.type === "ObjectPattern" && K.properties.length > 2 && K.properties.some((de)=>$(de) && (!de.shorthand || de.value && de.value.type === "AssignmentPattern"));
                            }
                            return false;
                        }
                        function b(W) {
                            return W.type === "AssignmentExpression";
                        }
                        function B(W) {
                            return b(W) || W.type === "VariableDeclarator";
                        }
                        function k(W) {
                            let K = M(W);
                            if (t1(K)) {
                                let de = W.type === "TSTypeAliasDeclaration" ? "constraint" : "bound";
                                if (K.length > 1 && K.some((ue)=>ue[de] || ue.default)) return true;
                            }
                            return false;
                        }
                        function M(W) {
                            return R(W) && W.typeParameters && W.typeParameters.params ? W.typeParameters.params : null;
                        }
                        function R(W) {
                            return W.type === "TSTypeAliasDeclaration" || W.type === "TypeAlias";
                        }
                        function q(W) {
                            if (W.type !== "VariableDeclarator") return false;
                            let { typeAnnotation: K } = W.id;
                            if (!K || !K.typeAnnotation) return false;
                            let de = L(K.typeAnnotation);
                            return t1(de) && de.length > 1 && de.some((ue)=>t1(L(ue)) || ue.type === "TSConditionalType");
                        }
                        function J(W) {
                            return W.type === "VariableDeclarator" && W.init && W.init.type === "ArrowFunctionExpression";
                        }
                        function L(W) {
                            return Q(W) && W.typeParameters && W.typeParameters.params ? W.typeParameters.params : null;
                        }
                        function Q(W) {
                            return W.type === "TSTypeReference" || W.type === "GenericTypeAnnotation";
                        }
                        function V(W, K, de) {
                            let ue = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false, Fe = W.getValue(), z = ()=>V(W, K, de, true);
                            if (Fe.type === "TSNonNullExpression") return W.call(z, "expression");
                            if (w(Fe)) {
                                if (T(W, K, de).label === "member-chain") return false;
                                let Z = N(Fe);
                                return !(Z.length === 0 || Z.length === 1 && Y(Z[0], K)) || ee(Fe, de) ? false : W.call(z, "callee");
                            }
                            return E(Fe) ? W.call(z, "object") : ue && (Fe.type === "Identifier" || Fe.type === "ThisExpression");
                        }
                        var j = 0.25;
                        function Y(W, K) {
                            let { printWidth: de } = K;
                            if (I(W)) return false;
                            let ue = de * j;
                            if (W.type === "ThisExpression" || W.type === "Identifier" && W.name.length <= ue || P(W) && !I(W.argument)) return true;
                            let Fe = W.type === "Literal" && "regex" in W && W.regex.pattern || W.type === "RegExpLiteral" && W.pattern;
                            return Fe ? Fe.length <= ue : f2(W) ? x(W).length <= ue : W.type === "TemplateLiteral" ? W.expressions.length === 0 && W.quasis[0].value.raw.length <= ue && !W.quasis[0].value.raw.includes(`
`) : F(W);
                        }
                        function ie(W, K, de) {
                            if (!$(W)) return false;
                            K = p(K);
                            let ue = 3;
                            return typeof K == "string" && s(K) < de.tabWidth + ue;
                        }
                        function ee(W, K) {
                            let de = ce(W);
                            if (t1(de)) {
                                if (de.length > 1) return true;
                                if (de.length === 1) {
                                    let Fe = de[0];
                                    if (Fe.type === "TSUnionType" || Fe.type === "UnionTypeAnnotation" || Fe.type === "TSIntersectionType" || Fe.type === "IntersectionTypeAnnotation" || Fe.type === "TSTypeLiteral" || Fe.type === "ObjectTypeAnnotation") return true;
                                }
                                let ue = W.typeParameters ? "typeParameters" : "typeArguments";
                                if (y(K(ue))) return true;
                            }
                            return false;
                        }
                        function ce(W) {
                            return W.typeParameters && W.typeParameters.params || W.typeArguments && W.typeArguments.params;
                        }
                        r.exports = {
                            printVariableDeclarator: o,
                            printAssignmentExpression: C,
                            printAssignment: m,
                            isArrowFunctionVariableDeclarator: J
                        };
                    }
                }), Lr = te({
                    "src/language-js/print/function-parameters.js" (e, r) {
                        "use strict";
                        ne();
                        var { getNextNonSpaceNonCommentCharacter: t1 } = Ue(), { printDanglingComments: s } = et(), { builders: { line: a2, hardline: n, softline: u, group: i, indent: l, ifBreak: p }, utils: { removeLines: y, willBreak: h } } = qe(), { getFunctionParameters: g, iterateFunctionParametersPath: c, isSimpleType: f2, isTestCall: F, isTypeAnnotationAFunction: _2, isObjectType: w, isObjectTypePropertyAFunction: E, hasRestParameter: N, shouldPrintComma: x, hasComment: I, isNextLineEmpty: P } = Ke(), { locEnd: $ } = ut(), { ArgExpansionBailout: D } = Qt(), { printFunctionTypeParameters: T } = ct();
                        function m(v, S, b, B, k) {
                            let M = v.getValue(), R = g(M), q = k ? T(v, b, S) : "";
                            if (R.length === 0) return [
                                q,
                                "(",
                                s(v, b, true, (ie)=>t1(b.originalText, ie, $) === ")"),
                                ")"
                            ];
                            let J = v.getParentNode(), L = F(J), Q = C(M), V = [];
                            if (c(v, (ie, ee)=>{
                                let ce = ee === R.length - 1;
                                ce && M.rest && V.push("..."), V.push(S()), !ce && (V.push(","), L || Q ? V.push(" ") : P(R[ee], b) ? V.push(n, n) : V.push(a2));
                            }), B) {
                                if (h(q) || h(V)) throw new D();
                                return i([
                                    y(q),
                                    "(",
                                    y(V),
                                    ")"
                                ]);
                            }
                            let j = R.every((ie)=>!ie.decorators);
                            return Q && j ? [
                                q,
                                "(",
                                ...V,
                                ")"
                            ] : L ? [
                                q,
                                "(",
                                ...V,
                                ")"
                            ] : (E(J) || _2(J) || J.type === "TypeAlias" || J.type === "UnionTypeAnnotation" || J.type === "TSUnionType" || J.type === "IntersectionTypeAnnotation" || J.type === "FunctionTypeAnnotation" && J.returnType === M) && R.length === 1 && R[0].name === null && M.this !== R[0] && R[0].typeAnnotation && M.typeParameters === null && f2(R[0].typeAnnotation) && !M.rest ? b.arrowParens === "always" ? [
                                "(",
                                ...V,
                                ")"
                            ] : V : [
                                q,
                                "(",
                                l([
                                    u,
                                    ...V
                                ]),
                                p(!N(M) && x(b, "all") ? "," : ""),
                                u,
                                ")"
                            ];
                        }
                        function C(v) {
                            if (!v) return false;
                            let S = g(v);
                            if (S.length !== 1) return false;
                            let [b] = S;
                            return !I(b) && (b.type === "ObjectPattern" || b.type === "ArrayPattern" || b.type === "Identifier" && b.typeAnnotation && (b.typeAnnotation.type === "TypeAnnotation" || b.typeAnnotation.type === "TSTypeAnnotation") && w(b.typeAnnotation.typeAnnotation) || b.type === "FunctionTypeParam" && w(b.typeAnnotation) || b.type === "AssignmentPattern" && (b.left.type === "ObjectPattern" || b.left.type === "ArrayPattern") && (b.right.type === "Identifier" || b.right.type === "ObjectExpression" && b.right.properties.length === 0 || b.right.type === "ArrayExpression" && b.right.elements.length === 0));
                        }
                        function o(v) {
                            let S;
                            return v.returnType ? (S = v.returnType, S.typeAnnotation && (S = S.typeAnnotation)) : v.typeAnnotation && (S = v.typeAnnotation), S;
                        }
                        function d(v, S) {
                            let b = o(v);
                            if (!b) return false;
                            let B = v.typeParameters && v.typeParameters.params;
                            if (B) {
                                if (B.length > 1) return false;
                                if (B.length === 1) {
                                    let k = B[0];
                                    if (k.constraint || k.default) return false;
                                }
                            }
                            return g(v).length === 1 && (w(b) || h(S));
                        }
                        r.exports = {
                            printFunctionParameters: m,
                            shouldHugFunctionParameters: C,
                            shouldGroupFunctionParameters: d
                        };
                    }
                }), Or = te({
                    "src/language-js/print/type-annotation.js" (e, r) {
                        "use strict";
                        ne();
                        var { printComments: t1, printDanglingComments: s } = et(), { isNonEmptyArray: a2 } = Ue(), { builders: { group: n, join: u, line: i, softline: l, indent: p, align: y, ifBreak: h } } = qe(), g = qt(), { locStart: c } = ut(), { isSimpleType: f2, isObjectType: F, hasLeadingOwnLineComment: _2, isObjectTypePropertyAFunction: w, shouldPrintComma: E } = Ke(), { printAssignment: N } = tr(), { printFunctionParameters: x, shouldGroupFunctionParameters: I } = Lr(), { printArrayItems: P } = er();
                        function $(b) {
                            if (f2(b) || F(b)) return true;
                            if (b.type === "UnionTypeAnnotation" || b.type === "TSUnionType") {
                                let B = b.types.filter((M)=>M.type === "VoidTypeAnnotation" || M.type === "TSVoidKeyword" || M.type === "NullLiteralTypeAnnotation" || M.type === "TSNullKeyword").length, k = b.types.some((M)=>M.type === "ObjectTypeAnnotation" || M.type === "TSTypeLiteral" || M.type === "GenericTypeAnnotation" || M.type === "TSTypeReference");
                                if (b.types.length - 1 === B && k) return true;
                            }
                            return false;
                        }
                        function D(b, B, k) {
                            let M = B.semi ? ";" : "", R = b.getValue(), q = [];
                            return q.push("opaque type ", k("id"), k("typeParameters")), R.supertype && q.push(": ", k("supertype")), R.impltype && q.push(" = ", k("impltype")), q.push(M), q;
                        }
                        function T(b, B, k) {
                            let M = B.semi ? ";" : "", R = b.getValue(), q = [];
                            R.declare && q.push("declare "), q.push("type ", k("id"), k("typeParameters"));
                            let J = R.type === "TSTypeAliasDeclaration" ? "typeAnnotation" : "right";
                            return [
                                N(b, B, k, q, " =", J),
                                M
                            ];
                        }
                        function m(b, B, k) {
                            let M = b.getValue(), R = b.map(k, "types"), q = [], J = false;
                            for(let L = 0; L < R.length; ++L)L === 0 ? q.push(R[L]) : F(M.types[L - 1]) && F(M.types[L]) ? q.push([
                                " & ",
                                J ? p(R[L]) : R[L]
                            ]) : !F(M.types[L - 1]) && !F(M.types[L]) ? q.push(p([
                                " &",
                                i,
                                R[L]
                            ])) : (L > 1 && (J = true), q.push(" & ", L > 1 ? p(R[L]) : R[L]));
                            return n(q);
                        }
                        function C(b, B, k) {
                            let M = b.getValue(), R = b.getParentNode(), q = R.type !== "TypeParameterInstantiation" && R.type !== "TSTypeParameterInstantiation" && R.type !== "GenericTypeAnnotation" && R.type !== "TSTypeReference" && R.type !== "TSTypeAssertion" && R.type !== "TupleTypeAnnotation" && R.type !== "TSTupleType" && !(R.type === "FunctionTypeParam" && !R.name && b.getParentNode(1).this !== R) && !((R.type === "TypeAlias" || R.type === "VariableDeclarator" || R.type === "TSTypeAliasDeclaration") && _2(B.originalText, M)), J = $(M), L = b.map((j)=>{
                                let Y = k();
                                return J || (Y = y(2, Y)), t1(j, Y, B);
                            }, "types");
                            if (J) return u(" | ", L);
                            let Q = q && !_2(B.originalText, M), V = [
                                h([
                                    Q ? i : "",
                                    "| "
                                ]),
                                u([
                                    i,
                                    "| "
                                ], L)
                            ];
                            return g(b, B) ? n([
                                p(V),
                                l
                            ]) : R.type === "TupleTypeAnnotation" && R.types.length > 1 || R.type === "TSTupleType" && R.elementTypes.length > 1 ? n([
                                p([
                                    h([
                                        "(",
                                        l
                                    ]),
                                    V
                                ]),
                                l,
                                h(")")
                            ]) : n(q ? p(V) : V);
                        }
                        function o(b, B, k) {
                            let M = b.getValue(), R = [], q = b.getParentNode(0), J = b.getParentNode(1), L = b.getParentNode(2), Q = M.type === "TSFunctionType" || !((q.type === "ObjectTypeProperty" || q.type === "ObjectTypeInternalSlot") && !q.variance && !q.optional && c(q) === c(M) || q.type === "ObjectTypeCallProperty" || L && L.type === "DeclareFunction"), V = Q && (q.type === "TypeAnnotation" || q.type === "TSTypeAnnotation"), j = V && Q && (q.type === "TypeAnnotation" || q.type === "TSTypeAnnotation") && J.type === "ArrowFunctionExpression";
                            w(q) && (Q = true, V = true), j && R.push("(");
                            let Y = x(b, k, B, false, true), ie = M.returnType || M.predicate || M.typeAnnotation ? [
                                Q ? " => " : ": ",
                                k("returnType"),
                                k("predicate"),
                                k("typeAnnotation")
                            ] : "", ee = I(M, ie);
                            return R.push(ee ? n(Y) : Y), ie && R.push(ie), j && R.push(")"), n(R);
                        }
                        function d(b, B, k) {
                            let M = b.getValue(), R = M.type === "TSTupleType" ? "elementTypes" : "types", q = M[R], J = a2(q), L = J ? l : "";
                            return n([
                                "[",
                                p([
                                    L,
                                    P(b, B, R, k)
                                ]),
                                h(J && E(B, "all") ? "," : ""),
                                s(b, B, true),
                                L,
                                "]"
                            ]);
                        }
                        function v(b, B, k) {
                            let M = b.getValue(), R = M.type === "OptionalIndexedAccessType" && M.optional ? "?.[" : "[";
                            return [
                                k("objectType"),
                                R,
                                k("indexType"),
                                "]"
                            ];
                        }
                        function S(b, B, k) {
                            let M = b.getValue();
                            return [
                                M.postfix ? "" : k,
                                B("typeAnnotation"),
                                M.postfix ? k : ""
                            ];
                        }
                        r.exports = {
                            printOpaqueType: D,
                            printTypeAlias: T,
                            printIntersectionType: m,
                            printUnionType: C,
                            printFunctionType: o,
                            printTupleType: d,
                            printIndexedAccessType: v,
                            shouldHugType: $,
                            printJSDocType: S
                        };
                    }
                }), jr = te({
                    "src/language-js/print/type-parameters.js" (e, r) {
                        "use strict";
                        ne();
                        var { printDanglingComments: t1 } = et(), { builders: { join: s, line: a2, hardline: n, softline: u, group: i, indent: l, ifBreak: p } } = qe(), { isTestCall: y, hasComment: h, CommentCheckFlags: g, isTSXFile: c, shouldPrintComma: f2, getFunctionParameters: F, isObjectType: _2, getTypeScriptMappedTypeModifier: w } = Ke(), { createGroupIdMapper: E } = Ue(), { shouldHugType: N } = Or(), { isArrowFunctionVariableDeclarator: x } = tr(), I = E("typeParameters");
                        function P(T, m, C, o) {
                            let d = T.getValue();
                            if (!d[o]) return "";
                            if (!Array.isArray(d[o])) return C(o);
                            let v = T.getNode(2), S = v && y(v), b = T.match((M)=>!(M[o].length === 1 && _2(M[o][0])), void 0, (M, R)=>R === "typeAnnotation", (M)=>M.type === "Identifier", x);
                            if (d[o].length === 0 || !b && (S || d[o].length === 1 && (d[o][0].type === "NullableTypeAnnotation" || N(d[o][0])))) return [
                                "<",
                                s(", ", T.map(C, o)),
                                $(T, m),
                                ">"
                            ];
                            let k = d.type === "TSTypeParameterInstantiation" ? "" : F(d).length === 1 && c(m) && !d[o][0].constraint && T.getParentNode().type === "ArrowFunctionExpression" ? "," : f2(m, "all") ? p(",") : "";
                            return i([
                                "<",
                                l([
                                    u,
                                    s([
                                        ",",
                                        a2
                                    ], T.map(C, o))
                                ]),
                                k,
                                u,
                                ">"
                            ], {
                                id: I(d)
                            });
                        }
                        function $(T, m) {
                            let C = T.getValue();
                            if (!h(C, g.Dangling)) return "";
                            let o = !h(C, g.Line), d = t1(T, m, o);
                            return o ? d : [
                                d,
                                n
                            ];
                        }
                        function D(T, m, C) {
                            let o = T.getValue(), d = [
                                o.type === "TSTypeParameter" && o.const ? "const " : ""
                            ], v = T.getParentNode();
                            return v.type === "TSMappedType" ? (v.readonly && d.push(w(v.readonly, "readonly"), " "), d.push("[", C("name")), o.constraint && d.push(" in ", C("constraint")), v.nameType && d.push(" as ", T.callParent(()=>C("nameType"))), d.push("]"), d) : (o.variance && d.push(C("variance")), o.in && d.push("in "), o.out && d.push("out "), d.push(C("name")), o.bound && d.push(": ", C("bound")), o.constraint && d.push(" extends ", C("constraint")), o.default && d.push(" = ", C("default")), d);
                        }
                        r.exports = {
                            printTypeParameter: D,
                            printTypeParameters: P,
                            getTypeParametersGroupId: I
                        };
                    }
                }), rr = te({
                    "src/language-js/print/property.js" (e, r) {
                        "use strict";
                        ne();
                        var { printComments: t1 } = et(), { printString: s, printNumber: a2 } = Ue(), { isNumericLiteral: n, isSimpleNumber: u, isStringLiteral: i, isStringPropSafeToUnquote: l, rawText: p } = Ke(), { printAssignment: y } = tr(), h = /* @__PURE__ */ new WeakMap();
                        function g(f2, F, _2) {
                            let w = f2.getNode();
                            if (w.computed) return [
                                "[",
                                _2("key"),
                                "]"
                            ];
                            let E = f2.getParentNode(), { key: N } = w;
                            if (F.quoteProps === "consistent" && !h.has(E)) {
                                let x = (E.properties || E.body || E.members).some((I)=>!I.computed && I.key && i(I.key) && !l(I, F));
                                h.set(E, x);
                            }
                            if ((N.type === "Identifier" || n(N) && u(a2(p(N))) && String(N.value) === a2(p(N)) && !(F.parser === "typescript" || F.parser === "babel-ts")) && (F.parser === "json" || F.quoteProps === "consistent" && h.get(E))) {
                                let x = s(JSON.stringify(N.type === "Identifier" ? N.name : N.value.toString()), F);
                                return f2.call((I)=>t1(I, x, F), "key");
                            }
                            return l(w, F) && (F.quoteProps === "as-needed" || F.quoteProps === "consistent" && !h.get(E)) ? f2.call((x)=>t1(x, /^\d/.test(N.value) ? a2(N.value) : N.value, F), "key") : _2("key");
                        }
                        function c(f2, F, _2) {
                            return f2.getValue().shorthand ? _2("value") : y(f2, F, _2, g(f2, F, _2), ":", "value");
                        }
                        r.exports = {
                            printProperty: c,
                            printPropertyKey: g
                        };
                    }
                }), qr = te({
                    "src/language-js/print/function.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Zt(), { printDanglingComments: s, printCommentsSeparately: a2 } = et(), n = lt(), { getNextNonSpaceNonCommentCharacterIndex: u } = Ue(), { builders: { line: i, softline: l, group: p, indent: y, ifBreak: h, hardline: g, join: c, indentIfBreak: f2 }, utils: { removeLines: F, willBreak: _2 } } = qe(), { ArgExpansionBailout: w } = Qt(), { getFunctionParameters: E, hasLeadingOwnLineComment: N, isFlowAnnotationComment: x, isJsxNode: I, isTemplateOnItsOwnLine: P, shouldPrintComma: $, startsWithNoLookaheadToken: D, isBinaryish: T, isLineComment: m, hasComment: C, getComments: o, CommentCheckFlags: d, isCallLikeExpression: v, isCallExpression: S, getCallArguments: b, hasNakedLeftSide: B, getLeftSide: k } = Ke(), { locEnd: M } = ut(), { printFunctionParameters: R, shouldGroupFunctionParameters: q } = Lr(), { printPropertyKey: J } = rr(), { printFunctionTypeParameters: L } = ct();
                        function Q(U, Z, se, fe) {
                            let ge = U.getValue(), he = false;
                            if ((ge.type === "FunctionDeclaration" || ge.type === "FunctionExpression") && fe && fe.expandLastArg) {
                                let Pe = U.getParentNode();
                                S(Pe) && b(Pe).length > 1 && (he = true);
                            }
                            let we = [];
                            ge.type === "TSDeclareFunction" && ge.declare && we.push("declare "), ge.async && we.push("async "), ge.generator ? we.push("function* ") : we.push("function "), ge.id && we.push(Z("id"));
                            let ke = R(U, Z, se, he), Re = K(U, Z, se), Ne = q(ge, Re);
                            return we.push(L(U, se, Z), p([
                                Ne ? p(ke) : ke,
                                Re
                            ]), ge.body ? " " : "", Z("body")), se.semi && (ge.declare || !ge.body) && we.push(";"), we;
                        }
                        function V(U, Z, se) {
                            let fe = U.getNode(), { kind: ge } = fe, he = fe.value || fe, we = [];
                            return !ge || ge === "init" || ge === "method" || ge === "constructor" ? he.async && we.push("async ") : (t1.ok(ge === "get" || ge === "set"), we.push(ge, " ")), he.generator && we.push("*"), we.push(J(U, Z, se), fe.optional || fe.key.optional ? "?" : ""), fe === he ? we.push(j(U, Z, se)) : he.type === "FunctionExpression" ? we.push(U.call((ke)=>j(ke, Z, se), "value")) : we.push(se("value")), we;
                        }
                        function j(U, Z, se) {
                            let fe = U.getNode(), ge = R(U, se, Z), he = K(U, se, Z), we = q(fe, he), ke = [
                                L(U, Z, se),
                                p([
                                    we ? p(ge) : ge,
                                    he
                                ])
                            ];
                            return fe.body ? ke.push(" ", se("body")) : ke.push(Z.semi ? ";" : ""), ke;
                        }
                        function Y(U, Z, se, fe) {
                            let ge = U.getValue(), he = [];
                            if (ge.async && he.push("async "), W(U, Z)) he.push(se([
                                "params",
                                0
                            ]));
                            else {
                                let ke = fe && (fe.expandLastArg || fe.expandFirstArg), Re = K(U, se, Z);
                                if (ke) {
                                    if (_2(Re)) throw new w();
                                    Re = p(F(Re));
                                }
                                he.push(p([
                                    R(U, se, Z, ke, true),
                                    Re
                                ]));
                            }
                            let we = s(U, Z, true, (ke)=>{
                                let Re = u(Z.originalText, ke, M);
                                return Re !== false && Z.originalText.slice(Re, Re + 2) === "=>";
                            });
                            return we && he.push(" ", we), he;
                        }
                        function ie(U, Z, se, fe, ge, he) {
                            let we = U.getName(), ke = U.getParentNode(), Re = v(ke) && we === "callee", Ne = Boolean(Z && Z.assignmentLayout), Pe = he.body.type !== "BlockStatement" && he.body.type !== "ObjectExpression" && he.body.type !== "SequenceExpression", oe = Re && Pe || Z && Z.assignmentLayout === "chain-tail-arrow-chain", H = Symbol("arrow-chain");
                            return he.body.type === "SequenceExpression" && (ge = p([
                                "(",
                                y([
                                    l,
                                    ge
                                ]),
                                l,
                                ")"
                            ])), p([
                                p(y([
                                    Re || Ne ? l : "",
                                    p(c([
                                        " =>",
                                        i
                                    ], se), {
                                        shouldBreak: fe
                                    })
                                ]), {
                                    id: H,
                                    shouldBreak: oe
                                }),
                                " =>",
                                f2(Pe ? y([
                                    i,
                                    ge
                                ]) : [
                                    " ",
                                    ge
                                ], {
                                    groupId: H
                                }),
                                Re ? h(l, "", {
                                    groupId: H
                                }) : ""
                            ]);
                        }
                        function ee(U, Z, se, fe) {
                            let ge = U.getValue(), he = [], we = [], ke = false;
                            if (function H() {
                                let pe = Y(U, Z, se, fe);
                                if (he.length === 0) he.push(pe);
                                else {
                                    let { leading: X, trailing: le } = a2(U, Z);
                                    he.push([
                                        X,
                                        pe
                                    ]), we.unshift(le);
                                }
                                ke = ke || ge.returnType && E(ge).length > 0 || ge.typeParameters || E(ge).some((X)=>X.type !== "Identifier"), ge.body.type !== "ArrowFunctionExpression" || fe && fe.expandLastArg ? we.unshift(se("body", fe)) : (ge = ge.body, U.call(H, "body"));
                            }(), he.length > 1) return ie(U, fe, he, ke, we, ge);
                            let Re = he;
                            if (Re.push(" =>"), !N(Z.originalText, ge.body) && (ge.body.type === "ArrayExpression" || ge.body.type === "ObjectExpression" || ge.body.type === "BlockStatement" || I(ge.body) || P(ge.body, Z.originalText) || ge.body.type === "ArrowFunctionExpression" || ge.body.type === "DoExpression")) return p([
                                ...Re,
                                " ",
                                we
                            ]);
                            if (ge.body.type === "SequenceExpression") return p([
                                ...Re,
                                p([
                                    " (",
                                    y([
                                        l,
                                        we
                                    ]),
                                    l,
                                    ")"
                                ])
                            ]);
                            let Ne = (fe && fe.expandLastArg || U.getParentNode().type === "JSXExpressionContainer") && !C(ge), Pe = fe && fe.expandLastArg && $(Z, "all"), oe = ge.body.type === "ConditionalExpression" && !D(ge.body, (H)=>H.type === "ObjectExpression");
                            return p([
                                ...Re,
                                p([
                                    y([
                                        i,
                                        oe ? h("", "(") : "",
                                        we,
                                        oe ? h("", ")") : ""
                                    ]),
                                    Ne ? [
                                        h(Pe ? "," : ""),
                                        l
                                    ] : ""
                                ])
                            ]);
                        }
                        function ce(U) {
                            let Z = E(U);
                            return Z.length === 1 && !U.typeParameters && !C(U, d.Dangling) && Z[0].type === "Identifier" && !Z[0].typeAnnotation && !C(Z[0]) && !Z[0].optional && !U.predicate && !U.returnType;
                        }
                        function W(U, Z) {
                            if (Z.arrowParens === "always") return false;
                            if (Z.arrowParens === "avoid") {
                                let se = U.getValue();
                                return ce(se);
                            }
                            return false;
                        }
                        function K(U, Z, se) {
                            let fe = U.getValue(), ge = Z("returnType");
                            if (fe.returnType && x(se.originalText, fe.returnType)) return [
                                " /*: ",
                                ge,
                                " */"
                            ];
                            let he = [
                                ge
                            ];
                            return fe.returnType && fe.returnType.typeAnnotation && he.unshift(": "), fe.predicate && he.push(fe.returnType ? " " : ": ", Z("predicate")), he;
                        }
                        function de(U, Z, se) {
                            let fe = U.getValue(), ge = Z.semi ? ";" : "", he = [];
                            fe.argument && (z(Z, fe.argument) ? he.push([
                                " (",
                                y([
                                    g,
                                    se("argument")
                                ]),
                                g,
                                ")"
                            ]) : T(fe.argument) || fe.argument.type === "SequenceExpression" ? he.push(p([
                                h(" (", " "),
                                y([
                                    l,
                                    se("argument")
                                ]),
                                l,
                                h(")")
                            ])) : he.push(" ", se("argument")));
                            let we = o(fe), ke = n(we), Re = ke && m(ke);
                            return Re && he.push(ge), C(fe, d.Dangling) && he.push(" ", s(U, Z, true)), Re || he.push(ge), he;
                        }
                        function ue(U, Z, se) {
                            return [
                                "return",
                                de(U, Z, se)
                            ];
                        }
                        function Fe(U, Z, se) {
                            return [
                                "throw",
                                de(U, Z, se)
                            ];
                        }
                        function z(U, Z) {
                            if (N(U.originalText, Z)) return true;
                            if (B(Z)) {
                                let se = Z, fe;
                                for(; fe = k(se);)if (se = fe, N(U.originalText, se)) return true;
                            }
                            return false;
                        }
                        r.exports = {
                            printFunction: Q,
                            printArrowFunction: ee,
                            printMethod: V,
                            printReturnStatement: ue,
                            printThrowStatement: Fe,
                            printMethodInternal: j,
                            shouldPrintParamsWithoutParens: W
                        };
                    }
                }), nu = te({
                    "src/language-js/print/decorators.js" (e, r) {
                        "use strict";
                        ne();
                        var { isNonEmptyArray: t1, hasNewline: s } = Ue(), { builders: { line: a2, hardline: n, join: u, breakParent: i, group: l } } = qe(), { locStart: p, locEnd: y } = ut(), { getParentExportDeclaration: h } = Ke();
                        function g(w, E, N) {
                            let x = w.getValue();
                            return l([
                                u(a2, w.map(N, "decorators")),
                                F(x, E) ? n : a2
                            ]);
                        }
                        function c(w, E, N) {
                            return [
                                u(n, w.map(N, "declaration", "decorators")),
                                n
                            ];
                        }
                        function f2(w, E, N) {
                            let x = w.getValue(), { decorators: I } = x;
                            if (!t1(I) || _2(w.getParentNode())) return;
                            let P = x.type === "ClassExpression" || x.type === "ClassDeclaration" || F(x, E);
                            return [
                                h(w) ? n : P ? i : "",
                                u(a2, w.map(N, "decorators")),
                                a2
                            ];
                        }
                        function F(w, E) {
                            return w.decorators.some((N)=>s(E.originalText, y(N)));
                        }
                        function _2(w) {
                            if (w.type !== "ExportDefaultDeclaration" && w.type !== "ExportNamedDeclaration" && w.type !== "DeclareExportDeclaration") return false;
                            let E = w.declaration && w.declaration.decorators;
                            return t1(E) && p(w) === p(E[0]);
                        }
                        r.exports = {
                            printDecorators: f2,
                            printClassMemberDecorators: g,
                            printDecoratorsBeforeExport: c,
                            hasDecoratorsBeforeExport: _2
                        };
                    }
                }), nr = te({
                    "src/language-js/print/class.js" (e, r) {
                        "use strict";
                        ne();
                        var { isNonEmptyArray: t1, createGroupIdMapper: s } = Ue(), { printComments: a2, printDanglingComments: n } = et(), { builders: { join: u, line: i, hardline: l, softline: p, group: y, indent: h, ifBreak: g } } = qe(), { hasComment: c, CommentCheckFlags: f2 } = Ke(), { getTypeParametersGroupId: F } = jr(), { printMethod: _2 } = qr(), { printOptionalToken: w, printTypeAnnotation: E, printDefiniteToken: N } = ct(), { printPropertyKey: x } = rr(), { printAssignment: I } = tr(), { printClassMemberDecorators: P } = nu();
                        function $(b, B, k) {
                            let M = b.getValue(), R = [];
                            M.declare && R.push("declare "), M.abstract && R.push("abstract "), R.push("class");
                            let q = M.id && c(M.id, f2.Trailing) || M.typeParameters && c(M.typeParameters, f2.Trailing) || M.superClass && c(M.superClass) || t1(M.extends) || t1(M.mixins) || t1(M.implements), J = [], L = [];
                            if (M.id && J.push(" ", k("id")), J.push(k("typeParameters")), M.superClass) {
                                let Q = [
                                    d(b, B, k),
                                    k("superTypeParameters")
                                ], V = b.call((j)=>[
                                        "extends ",
                                        a2(j, Q, B)
                                    ], "superClass");
                                q ? L.push(i, y(V)) : L.push(" ", V);
                            } else L.push(o(b, B, k, "extends"));
                            if (L.push(o(b, B, k, "mixins"), o(b, B, k, "implements")), q) {
                                let Q;
                                C(M) ? Q = [
                                    ...J,
                                    h(L)
                                ] : Q = h([
                                    ...J,
                                    L
                                ]), R.push(y(Q, {
                                    id: D(M)
                                }));
                            } else R.push(...J, ...L);
                            return R.push(" ", k("body")), R;
                        }
                        var D = s("heritageGroup");
                        function T(b) {
                            return g(l, "", {
                                groupId: D(b)
                            });
                        }
                        function m(b) {
                            return [
                                "superClass",
                                "extends",
                                "mixins",
                                "implements"
                            ].filter((B)=>Boolean(b[B])).length > 1;
                        }
                        function C(b) {
                            return b.typeParameters && !c(b.typeParameters, f2.Trailing | f2.Line) && !m(b);
                        }
                        function o(b, B, k, M) {
                            let R = b.getValue();
                            if (!t1(R[M])) return "";
                            let q = n(b, B, true, (J)=>{
                                let { marker: L } = J;
                                return L === M;
                            });
                            return [
                                C(R) ? g(" ", i, {
                                    groupId: F(R.typeParameters)
                                }) : i,
                                q,
                                q && l,
                                M,
                                y(h([
                                    i,
                                    u([
                                        ",",
                                        i
                                    ], b.map(k, M))
                                ]))
                            ];
                        }
                        function d(b, B, k) {
                            let M = k("superClass");
                            return b.getParentNode().type === "AssignmentExpression" ? y(g([
                                "(",
                                h([
                                    p,
                                    M
                                ]),
                                p,
                                ")"
                            ], M)) : M;
                        }
                        function v(b, B, k) {
                            let M = b.getValue(), R = [];
                            return t1(M.decorators) && R.push(P(b, B, k)), M.accessibility && R.push(M.accessibility + " "), M.readonly && R.push("readonly "), M.declare && R.push("declare "), M.static && R.push("static "), (M.type === "TSAbstractMethodDefinition" || M.abstract) && R.push("abstract "), M.override && R.push("override "), R.push(_2(b, B, k)), R;
                        }
                        function S(b, B, k) {
                            let M = b.getValue(), R = [], q = B.semi ? ";" : "";
                            return t1(M.decorators) && R.push(P(b, B, k)), M.accessibility && R.push(M.accessibility + " "), M.declare && R.push("declare "), M.static && R.push("static "), (M.type === "TSAbstractPropertyDefinition" || M.type === "TSAbstractAccessorProperty" || M.abstract) && R.push("abstract "), M.override && R.push("override "), M.readonly && R.push("readonly "), M.variance && R.push(k("variance")), (M.type === "ClassAccessorProperty" || M.type === "AccessorProperty" || M.type === "TSAbstractAccessorProperty") && R.push("accessor "), R.push(x(b, B, k), w(b), N(b), E(b, B, k)), [
                                I(b, B, k, R, " =", "value"),
                                q
                            ];
                        }
                        r.exports = {
                            printClass: $,
                            printClassMethod: v,
                            printClassProperty: S,
                            printHardlineAfterHeritage: T
                        };
                    }
                }), bo = te({
                    "src/language-js/print/interface.js" (e, r) {
                        "use strict";
                        ne();
                        var { isNonEmptyArray: t1 } = Ue(), { builders: { join: s, line: a2, group: n, indent: u, ifBreak: i } } = qe(), { hasComment: l, identity: p, CommentCheckFlags: y } = Ke(), { getTypeParametersGroupId: h } = jr(), { printTypeScriptModifiers: g } = ct();
                        function c(f2, F, _2) {
                            let w = f2.getValue(), E = [];
                            w.declare && E.push("declare "), w.type === "TSInterfaceDeclaration" && E.push(w.abstract ? "abstract " : "", g(f2, F, _2)), E.push("interface");
                            let N = [], x = [];
                            w.type !== "InterfaceTypeAnnotation" && N.push(" ", _2("id"), _2("typeParameters"));
                            let I = w.typeParameters && !l(w.typeParameters, y.Trailing | y.Line);
                            return t1(w.extends) && x.push(I ? i(" ", a2, {
                                groupId: h(w.typeParameters)
                            }) : a2, "extends ", (w.extends.length === 1 ? p : u)(s([
                                ",",
                                a2
                            ], f2.map(_2, "extends")))), w.id && l(w.id, y.Trailing) || t1(w.extends) ? I ? E.push(n([
                                ...N,
                                u(x)
                            ])) : E.push(n(u([
                                ...N,
                                ...x
                            ]))) : E.push(...N, ...x), E.push(" ", _2("body")), n(E);
                        }
                        r.exports = {
                            printInterface: c
                        };
                    }
                }), To = te({
                    "src/language-js/print/module.js" (e, r) {
                        "use strict";
                        ne();
                        var { isNonEmptyArray: t1 } = Ue(), { builders: { softline: s, group: a2, indent: n, join: u, line: i, ifBreak: l, hardline: p } } = qe(), { printDanglingComments: y } = et(), { hasComment: h, CommentCheckFlags: g, shouldPrintComma: c, needsHardlineAfterDanglingComment: f2, isStringLiteral: F, rawText: _2 } = Ke(), { locStart: w, hasSameLoc: E } = ut(), { hasDecoratorsBeforeExport: N, printDecoratorsBeforeExport: x } = nu();
                        function I(S, b, B) {
                            let k = S.getValue(), M = b.semi ? ";" : "", R = [], { importKind: q } = k;
                            return R.push("import"), q && q !== "value" && R.push(" ", q), R.push(m(S, b, B), T(S, b, B), o(S, b, B), M), R;
                        }
                        function P(S, b, B) {
                            let k = S.getValue(), M = [];
                            N(k) && M.push(x(S, b, B));
                            let { type: R, exportKind: q, declaration: J } = k;
                            return M.push("export"), (k.default || R === "ExportDefaultDeclaration") && M.push(" default"), h(k, g.Dangling) && (M.push(" ", y(S, b, true)), f2(k) && M.push(p)), J ? M.push(" ", B("declaration")) : M.push(q === "type" ? " type" : "", m(S, b, B), T(S, b, B), o(S, b, B)), D(k, b) && M.push(";"), M;
                        }
                        function $(S, b, B) {
                            let k = S.getValue(), M = b.semi ? ";" : "", R = [], { exportKind: q, exported: J } = k;
                            return R.push("export"), q === "type" && R.push(" type"), R.push(" *"), J && R.push(" as ", B("exported")), R.push(T(S, b, B), o(S, b, B), M), R;
                        }
                        function D(S, b) {
                            if (!b.semi) return false;
                            let { type: B, declaration: k } = S, M = S.default || B === "ExportDefaultDeclaration";
                            if (!k) return true;
                            let { type: R } = k;
                            return !!(M && R !== "ClassDeclaration" && R !== "FunctionDeclaration" && R !== "TSInterfaceDeclaration" && R !== "DeclareClass" && R !== "DeclareFunction" && R !== "TSDeclareFunction" && R !== "EnumDeclaration");
                        }
                        function T(S, b, B) {
                            let k = S.getValue();
                            if (!k.source) return "";
                            let M = [];
                            return C(k, b) || M.push(" from"), M.push(" ", B("source")), M;
                        }
                        function m(S, b, B) {
                            let k = S.getValue();
                            if (C(k, b)) return "";
                            let M = [
                                " "
                            ];
                            if (t1(k.specifiers)) {
                                let R = [], q = [];
                                S.each(()=>{
                                    let J = S.getValue().type;
                                    if (J === "ExportNamespaceSpecifier" || J === "ExportDefaultSpecifier" || J === "ImportNamespaceSpecifier" || J === "ImportDefaultSpecifier") R.push(B());
                                    else if (J === "ExportSpecifier" || J === "ImportSpecifier") q.push(B());
                                    else throw new Error(`Unknown specifier type ${JSON.stringify(J)}`);
                                }, "specifiers"), M.push(u(", ", R)), q.length > 0 && (R.length > 0 && M.push(", "), q.length > 1 || R.length > 0 || k.specifiers.some((L)=>h(L)) ? M.push(a2([
                                    "{",
                                    n([
                                        b.bracketSpacing ? i : s,
                                        u([
                                            ",",
                                            i
                                        ], q)
                                    ]),
                                    l(c(b) ? "," : ""),
                                    b.bracketSpacing ? i : s,
                                    "}"
                                ])) : M.push([
                                    "{",
                                    b.bracketSpacing ? " " : "",
                                    ...q,
                                    b.bracketSpacing ? " " : "",
                                    "}"
                                ]));
                            } else M.push("{}");
                            return M;
                        }
                        function C(S, b) {
                            let { type: B, importKind: k, source: M, specifiers: R } = S;
                            return B !== "ImportDeclaration" || t1(R) || k === "type" ? false : !/{\s*}/.test(b.originalText.slice(w(S), w(M)));
                        }
                        function o(S, b, B) {
                            let k = S.getNode();
                            return t1(k.assertions) ? [
                                " assert {",
                                b.bracketSpacing ? " " : "",
                                u(", ", S.map(B, "assertions")),
                                b.bracketSpacing ? " " : "",
                                "}"
                            ] : "";
                        }
                        function d(S, b, B) {
                            let k = S.getNode(), { type: M } = k, R = [], q = M === "ImportSpecifier" ? k.importKind : k.exportKind;
                            q && q !== "value" && R.push(q, " ");
                            let J = M.startsWith("Import"), L = J ? "imported" : "local", Q = J ? "local" : "exported", V = k[L], j = k[Q], Y = "", ie = "";
                            return M === "ExportNamespaceSpecifier" || M === "ImportNamespaceSpecifier" ? Y = "*" : V && (Y = B(L)), j && !v(k) && (ie = B(Q)), R.push(Y, Y && ie ? " as " : "", ie), R;
                        }
                        function v(S) {
                            if (S.type !== "ImportSpecifier" && S.type !== "ExportSpecifier") return false;
                            let { local: b, [S.type === "ImportSpecifier" ? "imported" : "exported"]: B } = S;
                            if (b.type !== B.type || !E(b, B)) return false;
                            if (F(b)) return b.value === B.value && _2(b) === _2(B);
                            switch(b.type){
                                case "Identifier":
                                    return b.name === B.name;
                                default:
                                    return false;
                            }
                        }
                        r.exports = {
                            printImportDeclaration: I,
                            printExportDeclaration: P,
                            printExportAllDeclaration: $,
                            printModuleSpecifier: d
                        };
                    }
                }), uu = te({
                    "src/language-js/print/object.js" (e, r) {
                        "use strict";
                        ne();
                        var { printDanglingComments: t1 } = et(), { builders: { line: s, softline: a2, group: n, indent: u, ifBreak: i, hardline: l } } = qe(), { getLast: p, hasNewlineInRange: y, hasNewline: h, isNonEmptyArray: g } = Ue(), { shouldPrintComma: c, hasComment: f2, getComments: F, CommentCheckFlags: _2, isNextLineEmpty: w } = Ke(), { locStart: E, locEnd: N } = ut(), { printOptionalToken: x, printTypeAnnotation: I } = ct(), { shouldHugFunctionParameters: P } = Lr(), { shouldHugType: $ } = Or(), { printHardlineAfterHeritage: D } = nr();
                        function T(m, C, o) {
                            let d = C.semi ? ";" : "", v = m.getValue(), S;
                            v.type === "TSTypeLiteral" ? S = "members" : v.type === "TSInterfaceBody" ? S = "body" : S = "properties";
                            let b = v.type === "ObjectTypeAnnotation", B = [
                                S
                            ];
                            b && B.push("indexers", "callProperties", "internalSlots");
                            let k = B.map((W)=>v[W][0]).sort((W, K)=>E(W) - E(K))[0], M = m.getParentNode(0), R = b && M && (M.type === "InterfaceDeclaration" || M.type === "DeclareInterface" || M.type === "DeclareClass") && m.getName() === "body", q = v.type === "TSInterfaceBody" || R || v.type === "ObjectPattern" && M.type !== "FunctionDeclaration" && M.type !== "FunctionExpression" && M.type !== "ArrowFunctionExpression" && M.type !== "ObjectMethod" && M.type !== "ClassMethod" && M.type !== "ClassPrivateMethod" && M.type !== "AssignmentPattern" && M.type !== "CatchClause" && v.properties.some((W)=>W.value && (W.value.type === "ObjectPattern" || W.value.type === "ArrayPattern")) || v.type !== "ObjectPattern" && k && y(C.originalText, E(v), E(k)), J = R ? ";" : v.type === "TSInterfaceBody" || v.type === "TSTypeLiteral" ? i(d, ";") : ",", L = v.type === "RecordExpression" ? "#{" : v.exact ? "{|" : "{", Q = v.exact ? "|}" : "}", V = [];
                            for (let W of B)m.each((K)=>{
                                let de = K.getValue();
                                V.push({
                                    node: de,
                                    printed: o(),
                                    loc: E(de)
                                });
                            }, W);
                            B.length > 1 && V.sort((W, K)=>W.loc - K.loc);
                            let j = [], Y = V.map((W)=>{
                                let K = [
                                    ...j,
                                    n(W.printed)
                                ];
                                return j = [
                                    J,
                                    s
                                ], (W.node.type === "TSPropertySignature" || W.node.type === "TSMethodSignature" || W.node.type === "TSConstructSignatureDeclaration") && f2(W.node, _2.PrettierIgnore) && j.shift(), w(W.node, C) && j.push(l), K;
                            });
                            if (v.inexact) {
                                let W;
                                if (f2(v, _2.Dangling)) {
                                    let K = f2(v, _2.Line);
                                    W = [
                                        t1(m, C, true),
                                        K || h(C.originalText, N(p(F(v)))) ? l : s,
                                        "..."
                                    ];
                                } else W = [
                                    "..."
                                ];
                                Y.push([
                                    ...j,
                                    ...W
                                ]);
                            }
                            let ie = p(v[S]), ee = !(v.inexact || ie && ie.type === "RestElement" || ie && (ie.type === "TSPropertySignature" || ie.type === "TSCallSignatureDeclaration" || ie.type === "TSMethodSignature" || ie.type === "TSConstructSignatureDeclaration") && f2(ie, _2.PrettierIgnore)), ce;
                            if (Y.length === 0) {
                                if (!f2(v, _2.Dangling)) return [
                                    L,
                                    Q,
                                    I(m, C, o)
                                ];
                                ce = n([
                                    L,
                                    t1(m, C),
                                    a2,
                                    Q,
                                    x(m),
                                    I(m, C, o)
                                ]);
                            } else ce = [
                                R && g(v.properties) ? D(M) : "",
                                L,
                                u([
                                    C.bracketSpacing ? s : a2,
                                    ...Y
                                ]),
                                i(ee && (J !== "," || c(C)) ? J : ""),
                                C.bracketSpacing ? s : a2,
                                Q,
                                x(m),
                                I(m, C, o)
                            ];
                            return m.match((W)=>W.type === "ObjectPattern" && !W.decorators, (W, K, de)=>P(W) && (K === "params" || K === "parameters" || K === "this" || K === "rest") && de === 0) || m.match($, (W, K)=>K === "typeAnnotation", (W, K)=>K === "typeAnnotation", (W, K, de)=>P(W) && (K === "params" || K === "parameters" || K === "this" || K === "rest") && de === 0) || !q && m.match((W)=>W.type === "ObjectPattern", (W)=>W.type === "AssignmentExpression" || W.type === "VariableDeclarator") ? ce : n(ce, {
                                shouldBreak: q
                            });
                        }
                        r.exports = {
                            printObject: T
                        };
                    }
                }), dd = te({
                    "src/language-js/print/flow.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Zt(), { printDanglingComments: s } = et(), { printString: a2, printNumber: n } = Ue(), { builders: { hardline: u, softline: i, group: l, indent: p } } = qe(), { getParentExportDeclaration: y, isFunctionNotation: h, isGetterOrSetter: g, rawText: c, shouldPrintComma: f2 } = Ke(), { locStart: F, locEnd: _2 } = ut(), { replaceTextEndOfLine: w } = Yt(), { printClass: E } = nr(), { printOpaqueType: N, printTypeAlias: x, printIntersectionType: I, printUnionType: P, printFunctionType: $, printTupleType: D, printIndexedAccessType: T } = Or(), { printInterface: m } = bo(), { printTypeParameter: C, printTypeParameters: o } = jr(), { printExportDeclaration: d, printExportAllDeclaration: v } = To(), { printArrayItems: S } = er(), { printObject: b } = uu(), { printPropertyKey: B } = rr(), { printOptionalToken: k, printTypeAnnotation: M, printRestSpread: R } = ct();
                        function q(L, Q, V) {
                            let j = L.getValue(), Y = Q.semi ? ";" : "", ie = [];
                            switch(j.type){
                                case "DeclareClass":
                                    return J(L, E(L, Q, V));
                                case "DeclareFunction":
                                    return J(L, [
                                        "function ",
                                        V("id"),
                                        j.predicate ? " " : "",
                                        V("predicate"),
                                        Y
                                    ]);
                                case "DeclareModule":
                                    return J(L, [
                                        "module ",
                                        V("id"),
                                        " ",
                                        V("body")
                                    ]);
                                case "DeclareModuleExports":
                                    return J(L, [
                                        "module.exports",
                                        ": ",
                                        V("typeAnnotation"),
                                        Y
                                    ]);
                                case "DeclareVariable":
                                    return J(L, [
                                        "var ",
                                        V("id"),
                                        Y
                                    ]);
                                case "DeclareOpaqueType":
                                    return J(L, N(L, Q, V));
                                case "DeclareInterface":
                                    return J(L, m(L, Q, V));
                                case "DeclareTypeAlias":
                                    return J(L, x(L, Q, V));
                                case "DeclareExportDeclaration":
                                    return J(L, d(L, Q, V));
                                case "DeclareExportAllDeclaration":
                                    return J(L, v(L, Q, V));
                                case "OpaqueType":
                                    return N(L, Q, V);
                                case "TypeAlias":
                                    return x(L, Q, V);
                                case "IntersectionTypeAnnotation":
                                    return I(L, Q, V);
                                case "UnionTypeAnnotation":
                                    return P(L, Q, V);
                                case "FunctionTypeAnnotation":
                                    return $(L, Q, V);
                                case "TupleTypeAnnotation":
                                    return D(L, Q, V);
                                case "GenericTypeAnnotation":
                                    return [
                                        V("id"),
                                        o(L, Q, V, "typeParameters")
                                    ];
                                case "IndexedAccessType":
                                case "OptionalIndexedAccessType":
                                    return T(L, Q, V);
                                case "TypeAnnotation":
                                    return V("typeAnnotation");
                                case "TypeParameter":
                                    return C(L, Q, V);
                                case "TypeofTypeAnnotation":
                                    return [
                                        "typeof ",
                                        V("argument")
                                    ];
                                case "ExistsTypeAnnotation":
                                    return "*";
                                case "EmptyTypeAnnotation":
                                    return "empty";
                                case "MixedTypeAnnotation":
                                    return "mixed";
                                case "ArrayTypeAnnotation":
                                    return [
                                        V("elementType"),
                                        "[]"
                                    ];
                                case "BooleanLiteralTypeAnnotation":
                                    return String(j.value);
                                case "EnumDeclaration":
                                    return [
                                        "enum ",
                                        V("id"),
                                        " ",
                                        V("body")
                                    ];
                                case "EnumBooleanBody":
                                case "EnumNumberBody":
                                case "EnumStringBody":
                                case "EnumSymbolBody":
                                    {
                                        if (j.type === "EnumSymbolBody" || j.explicitType) {
                                            let ee = null;
                                            switch(j.type){
                                                case "EnumBooleanBody":
                                                    ee = "boolean";
                                                    break;
                                                case "EnumNumberBody":
                                                    ee = "number";
                                                    break;
                                                case "EnumStringBody":
                                                    ee = "string";
                                                    break;
                                                case "EnumSymbolBody":
                                                    ee = "symbol";
                                                    break;
                                            }
                                            ie.push("of ", ee, " ");
                                        }
                                        if (j.members.length === 0 && !j.hasUnknownMembers) ie.push(l([
                                            "{",
                                            s(L, Q),
                                            i,
                                            "}"
                                        ]));
                                        else {
                                            let ee = j.members.length > 0 ? [
                                                u,
                                                S(L, Q, "members", V),
                                                j.hasUnknownMembers || f2(Q) ? "," : ""
                                            ] : [];
                                            ie.push(l([
                                                "{",
                                                p([
                                                    ...ee,
                                                    ...j.hasUnknownMembers ? [
                                                        u,
                                                        "..."
                                                    ] : []
                                                ]),
                                                s(L, Q, true),
                                                u,
                                                "}"
                                            ]));
                                        }
                                        return ie;
                                    }
                                case "EnumBooleanMember":
                                case "EnumNumberMember":
                                case "EnumStringMember":
                                    return [
                                        V("id"),
                                        " = ",
                                        typeof j.init == "object" ? V("init") : String(j.init)
                                    ];
                                case "EnumDefaultedMember":
                                    return V("id");
                                case "FunctionTypeParam":
                                    {
                                        let ee = j.name ? V("name") : L.getParentNode().this === j ? "this" : "";
                                        return [
                                            ee,
                                            k(L),
                                            ee ? ": " : "",
                                            V("typeAnnotation")
                                        ];
                                    }
                                case "InterfaceDeclaration":
                                case "InterfaceTypeAnnotation":
                                    return m(L, Q, V);
                                case "ClassImplements":
                                case "InterfaceExtends":
                                    return [
                                        V("id"),
                                        V("typeParameters")
                                    ];
                                case "NullableTypeAnnotation":
                                    return [
                                        "?",
                                        V("typeAnnotation")
                                    ];
                                case "Variance":
                                    {
                                        let { kind: ee } = j;
                                        return t1.ok(ee === "plus" || ee === "minus"), ee === "plus" ? "+" : "-";
                                    }
                                case "ObjectTypeCallProperty":
                                    return j.static && ie.push("static "), ie.push(V("value")), ie;
                                case "ObjectTypeIndexer":
                                    return [
                                        j.static ? "static " : "",
                                        j.variance ? V("variance") : "",
                                        "[",
                                        V("id"),
                                        j.id ? ": " : "",
                                        V("key"),
                                        "]: ",
                                        V("value")
                                    ];
                                case "ObjectTypeProperty":
                                    {
                                        let ee = "";
                                        return j.proto ? ee = "proto " : j.static && (ee = "static "), [
                                            ee,
                                            g(j) ? j.kind + " " : "",
                                            j.variance ? V("variance") : "",
                                            B(L, Q, V),
                                            k(L),
                                            h(j) ? "" : ": ",
                                            V("value")
                                        ];
                                    }
                                case "ObjectTypeAnnotation":
                                    return b(L, Q, V);
                                case "ObjectTypeInternalSlot":
                                    return [
                                        j.static ? "static " : "",
                                        "[[",
                                        V("id"),
                                        "]]",
                                        k(L),
                                        j.method ? "" : ": ",
                                        V("value")
                                    ];
                                case "ObjectTypeSpreadProperty":
                                    return R(L, Q, V);
                                case "QualifiedTypeofIdentifier":
                                case "QualifiedTypeIdentifier":
                                    return [
                                        V("qualification"),
                                        ".",
                                        V("id")
                                    ];
                                case "StringLiteralTypeAnnotation":
                                    return w(a2(c(j), Q));
                                case "NumberLiteralTypeAnnotation":
                                    t1.strictEqual(typeof j.value, "number");
                                case "BigIntLiteralTypeAnnotation":
                                    return j.extra ? n(j.extra.raw) : n(j.raw);
                                case "TypeCastExpression":
                                    return [
                                        "(",
                                        V("expression"),
                                        M(L, Q, V),
                                        ")"
                                    ];
                                case "TypeParameterDeclaration":
                                case "TypeParameterInstantiation":
                                    {
                                        let ee = o(L, Q, V, "params");
                                        if (Q.parser === "flow") {
                                            let ce = F(j), W = _2(j), K = Q.originalText.lastIndexOf("/*", ce), de = Q.originalText.indexOf("*/", W);
                                            if (K !== -1 && de !== -1) {
                                                let ue = Q.originalText.slice(K + 2, de).trim();
                                                if (ue.startsWith("::") && !ue.includes("/*") && !ue.includes("*/")) return [
                                                    "/*:: ",
                                                    ee,
                                                    " */"
                                                ];
                                            }
                                        }
                                        return ee;
                                    }
                                case "InferredPredicate":
                                    return "%checks";
                                case "DeclaredPredicate":
                                    return [
                                        "%checks(",
                                        V("value"),
                                        ")"
                                    ];
                                case "AnyTypeAnnotation":
                                    return "any";
                                case "BooleanTypeAnnotation":
                                    return "boolean";
                                case "BigIntTypeAnnotation":
                                    return "bigint";
                                case "NullLiteralTypeAnnotation":
                                    return "null";
                                case "NumberTypeAnnotation":
                                    return "number";
                                case "SymbolTypeAnnotation":
                                    return "symbol";
                                case "StringTypeAnnotation":
                                    return "string";
                                case "VoidTypeAnnotation":
                                    return "void";
                                case "ThisTypeAnnotation":
                                    return "this";
                                case "Node":
                                case "Printable":
                                case "SourceLocation":
                                case "Position":
                                case "Statement":
                                case "Function":
                                case "Pattern":
                                case "Expression":
                                case "Declaration":
                                case "Specifier":
                                case "NamedSpecifier":
                                case "Comment":
                                case "MemberTypeAnnotation":
                                case "Type":
                                    throw new Error("unprintable type: " + JSON.stringify(j.type));
                            }
                        }
                        function J(L, Q) {
                            let V = y(L);
                            return V ? (t1.strictEqual(V.type, "DeclareExportDeclaration"), Q) : [
                                "declare ",
                                Q
                            ];
                        }
                        r.exports = {
                            printFlow: q
                        };
                    }
                }), gd = te({
                    "src/language-js/utils/is-ts-keyword-type.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s) {
                            let { type: a2 } = s;
                            return a2.startsWith("TS") && a2.endsWith("Keyword");
                        }
                        r.exports = t1;
                    }
                }), Bo = te({
                    "src/language-js/print/ternary.js" (e, r) {
                        "use strict";
                        ne();
                        var { hasNewlineInRange: t1 } = Ue(), { isJsxNode: s, getComments: a2, isCallExpression: n, isMemberExpression: u, isTSTypeExpression: i } = Ke(), { locStart: l, locEnd: p } = ut(), y = Pt(), { builders: { line: h, softline: g, group: c, indent: f2, align: F, ifBreak: _2, dedent: w, breakParent: E } } = qe();
                        function N(D) {
                            let T = [
                                D
                            ];
                            for(let m = 0; m < T.length; m++){
                                let C = T[m];
                                for (let o of [
                                    "test",
                                    "consequent",
                                    "alternate"
                                ]){
                                    let d = C[o];
                                    if (s(d)) return true;
                                    d.type === "ConditionalExpression" && T.push(d);
                                }
                            }
                            return false;
                        }
                        function x(D, T, m) {
                            let C = D.getValue(), o = C.type === "ConditionalExpression", d = o ? "alternate" : "falseType", v = D.getParentNode(), S = o ? m("test") : [
                                m("checkType"),
                                " ",
                                "extends",
                                " ",
                                m("extendsType")
                            ];
                            return v.type === C.type && v[d] === C ? F(2, S) : S;
                        }
                        var I = /* @__PURE__ */ new Map([
                            [
                                "AssignmentExpression",
                                "right"
                            ],
                            [
                                "VariableDeclarator",
                                "init"
                            ],
                            [
                                "ReturnStatement",
                                "argument"
                            ],
                            [
                                "ThrowStatement",
                                "argument"
                            ],
                            [
                                "UnaryExpression",
                                "argument"
                            ],
                            [
                                "YieldExpression",
                                "argument"
                            ]
                        ]);
                        function P(D) {
                            let T = D.getValue();
                            if (T.type !== "ConditionalExpression") return false;
                            let m, C = T;
                            for(let o = 0; !m; o++){
                                let d = D.getParentNode(o);
                                if (n(d) && d.callee === C || u(d) && d.object === C || d.type === "TSNonNullExpression" && d.expression === C) {
                                    C = d;
                                    continue;
                                }
                                d.type === "NewExpression" && d.callee === C || i(d) && d.expression === C ? (m = D.getParentNode(o + 1), C = d) : m = d;
                            }
                            return C === T ? false : m[I.get(m.type)] === C;
                        }
                        function $(D, T, m) {
                            let C = D.getValue(), o = C.type === "ConditionalExpression", d = o ? "consequent" : "trueType", v = o ? "alternate" : "falseType", S = o ? [
                                "test"
                            ] : [
                                "checkType",
                                "extendsType"
                            ], b = C[d], B = C[v], k = [], M = false, R = D.getParentNode(), q = R.type === C.type && S.some((ue)=>R[ue] === C), J = R.type === C.type && !q, L, Q, V = 0;
                            do Q = L || C, L = D.getParentNode(V), V++;
                            while (L && L.type === C.type && S.every((ue)=>L[ue] !== Q))
                            let j = L || R, Y = Q;
                            if (o && (s(C[S[0]]) || s(b) || s(B) || N(Y))) {
                                M = true, J = true;
                                let ue = (z)=>[
                                        _2("("),
                                        f2([
                                            g,
                                            z
                                        ]),
                                        g,
                                        _2(")")
                                    ], Fe = (z)=>z.type === "NullLiteral" || z.type === "Literal" && z.value === null || z.type === "Identifier" && z.name === "undefined";
                                k.push(" ? ", Fe(b) ? m(d) : ue(m(d)), " : ", B.type === C.type || Fe(B) ? m(v) : ue(m(v)));
                            } else {
                                let ue = [
                                    h,
                                    "? ",
                                    b.type === C.type ? _2("", "(") : "",
                                    F(2, m(d)),
                                    b.type === C.type ? _2("", ")") : "",
                                    h,
                                    ": ",
                                    B.type === C.type ? m(v) : F(2, m(v))
                                ];
                                k.push(R.type !== C.type || R[v] === C || q ? ue : T.useTabs ? w(f2(ue)) : F(Math.max(0, T.tabWidth - 2), ue));
                            }
                            let ee = [
                                ...S.map((ue)=>a2(C[ue])),
                                a2(b),
                                a2(B)
                            ].flat().some((ue)=>y(ue) && t1(T.originalText, l(ue), p(ue))), ce = (ue)=>R === j ? c(ue, {
                                    shouldBreak: ee
                                }) : ee ? [
                                    ue,
                                    E
                                ] : ue, W = !M && (u(R) || R.type === "NGPipeExpression" && R.left === C) && !R.computed, K = P(D), de = ce([
                                x(D, T, m),
                                J ? k : f2(k),
                                o && W && !K ? g : ""
                            ]);
                            return q || K ? c([
                                f2([
                                    g,
                                    de
                                ]),
                                g
                            ]) : de;
                        }
                        r.exports = {
                            printTernary: $
                        };
                    }
                }), No = te({
                    "src/language-js/print/statement.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { hardline: t1 } } = qe(), s = qt(), { getLeftSidePathName: a2, hasNakedLeftSide: n, isJsxNode: u, isTheOnlyJsxElementInMarkdown: i, hasComment: l, CommentCheckFlags: p, isNextLineEmpty: y } = Ke(), { shouldPrintParamsWithoutParens: h } = qr();
                        function g(x, I, P, $) {
                            let D = x.getValue(), T = [], m = D.type === "ClassBody", C = c(D[$]);
                            return x.each((o, d, v)=>{
                                let S = o.getValue();
                                if (S.type === "EmptyStatement") return;
                                let b = P();
                                !I.semi && !m && !i(I, o) && f2(o, I) ? l(S, p.Leading) ? T.push(P([], {
                                    needsSemi: true
                                })) : T.push(";", b) : T.push(b), !I.semi && m && E(S) && N(S, v[d + 1]) && T.push(";"), S !== C && (T.push(t1), y(S, I) && T.push(t1));
                            }, $), T;
                        }
                        function c(x) {
                            for(let I = x.length - 1; I >= 0; I--){
                                let P = x[I];
                                if (P.type !== "EmptyStatement") return P;
                            }
                        }
                        function f2(x, I) {
                            return x.getNode().type !== "ExpressionStatement" ? false : x.call(($)=>F($, I), "expression");
                        }
                        function F(x, I) {
                            let P = x.getValue();
                            switch(P.type){
                                case "ParenthesizedExpression":
                                case "TypeCastExpression":
                                case "ArrayExpression":
                                case "ArrayPattern":
                                case "TemplateLiteral":
                                case "TemplateElement":
                                case "RegExpLiteral":
                                    return true;
                                case "ArrowFunctionExpression":
                                    {
                                        if (!h(x, I)) return true;
                                        break;
                                    }
                                case "UnaryExpression":
                                    {
                                        let { prefix: $, operator: D } = P;
                                        if ($ && (D === "+" || D === "-")) return true;
                                        break;
                                    }
                                case "BindExpression":
                                    {
                                        if (!P.object) return true;
                                        break;
                                    }
                                case "Literal":
                                    {
                                        if (P.regex) return true;
                                        break;
                                    }
                                default:
                                    if (u(P)) return true;
                            }
                            return s(x, I) ? true : n(P) ? x.call(($)=>F($, I), ...a2(x, P)) : false;
                        }
                        function _2(x, I, P) {
                            return g(x, I, P, "body");
                        }
                        function w(x, I, P) {
                            return g(x, I, P, "consequent");
                        }
                        var E = (x)=>{
                            let { type: I } = x;
                            return I === "ClassProperty" || I === "PropertyDefinition" || I === "ClassPrivateProperty" || I === "ClassAccessorProperty" || I === "AccessorProperty" || I === "TSAbstractPropertyDefinition" || I === "TSAbstractAccessorProperty";
                        };
                        function N(x, I) {
                            let { type: P, name: $ } = x.key;
                            if (!x.computed && P === "Identifier" && ($ === "static" || $ === "get" || $ === "set" || $ === "accessor") && !x.value && !x.typeAnnotation) return true;
                            if (!I || I.static || I.accessibility) return false;
                            if (!I.computed) {
                                let D = I.key && I.key.name;
                                if (D === "in" || D === "instanceof") return true;
                            }
                            if (E(I) && I.variance && !I.static && !I.declare) return true;
                            switch(I.type){
                                case "ClassProperty":
                                case "PropertyDefinition":
                                case "TSAbstractPropertyDefinition":
                                    return I.computed;
                                case "MethodDefinition":
                                case "TSAbstractMethodDefinition":
                                case "ClassMethod":
                                case "ClassPrivateMethod":
                                    {
                                        if ((I.value ? I.value.async : I.async) || I.kind === "get" || I.kind === "set") return false;
                                        let T = I.value ? I.value.generator : I.generator;
                                        return !!(I.computed || T);
                                    }
                                case "TSIndexSignature":
                                    return true;
                            }
                            return false;
                        }
                        r.exports = {
                            printBody: _2,
                            printSwitchCaseConsequent: w
                        };
                    }
                }), wo = te({
                    "src/language-js/print/block.js" (e, r) {
                        "use strict";
                        ne();
                        var { printDanglingComments: t1 } = et(), { isNonEmptyArray: s } = Ue(), { builders: { hardline: a2, indent: n } } = qe(), { hasComment: u, CommentCheckFlags: i, isNextLineEmpty: l } = Ke(), { printHardlineAfterHeritage: p } = nr(), { printBody: y } = No();
                        function h(c, f2, F) {
                            let _2 = c.getValue(), w = [];
                            if (_2.type === "StaticBlock" && w.push("static "), _2.type === "ClassBody" && s(_2.body)) {
                                let N = c.getParentNode();
                                w.push(p(N));
                            }
                            w.push("{");
                            let E = g(c, f2, F);
                            if (E) w.push(n([
                                a2,
                                E
                            ]), a2);
                            else {
                                let N = c.getParentNode(), x = c.getParentNode(1);
                                N.type === "ArrowFunctionExpression" || N.type === "FunctionExpression" || N.type === "FunctionDeclaration" || N.type === "ObjectMethod" || N.type === "ClassMethod" || N.type === "ClassPrivateMethod" || N.type === "ForStatement" || N.type === "WhileStatement" || N.type === "DoWhileStatement" || N.type === "DoExpression" || N.type === "CatchClause" && !x.finalizer || N.type === "TSModuleDeclaration" || N.type === "TSDeclareFunction" || _2.type === "StaticBlock" || _2.type === "ClassBody" || w.push(a2);
                            }
                            return w.push("}"), w;
                        }
                        function g(c, f2, F) {
                            let _2 = c.getValue(), w = s(_2.directives), E = _2.body.some((I)=>I.type !== "EmptyStatement"), N = u(_2, i.Dangling);
                            if (!w && !E && !N) return "";
                            let x = [];
                            if (w && c.each((I, P, $)=>{
                                x.push(F()), (P < $.length - 1 || E || N) && (x.push(a2), l(I.getValue(), f2) && x.push(a2));
                            }, "directives"), E && x.push(y(c, f2, F)), N && x.push(t1(c, f2, true)), _2.type === "Program") {
                                let I = c.getParentNode();
                                (!I || I.type !== "ModuleExpression") && x.push(a2);
                            }
                            return x;
                        }
                        r.exports = {
                            printBlock: h,
                            printBlockBody: g
                        };
                    }
                }), yd = te({
                    "src/language-js/print/typescript.js" (e, r) {
                        "use strict";
                        ne();
                        var { printDanglingComments: t1 } = et(), { hasNewlineInRange: s } = Ue(), { builders: { join: a2, line: n, hardline: u, softline: i, group: l, indent: p, conditionalGroup: y, ifBreak: h } } = qe(), { isStringLiteral: g, getTypeScriptMappedTypeModifier: c, shouldPrintComma: f2, isCallExpression: F, isMemberExpression: _2 } = Ke(), w = gd(), { locStart: E, locEnd: N } = ut(), { printOptionalToken: x, printTypeScriptModifiers: I } = ct(), { printTernary: P } = Bo(), { printFunctionParameters: $, shouldGroupFunctionParameters: D } = Lr(), { printTemplateLiteral: T } = jt(), { printArrayItems: m } = er(), { printObject: C } = uu(), { printClassProperty: o, printClassMethod: d } = nr(), { printTypeParameter: v, printTypeParameters: S } = jr(), { printPropertyKey: b } = rr(), { printFunction: B, printMethodInternal: k } = qr(), { printInterface: M } = bo(), { printBlock: R } = wo(), { printTypeAlias: q, printIntersectionType: J, printUnionType: L, printFunctionType: Q, printTupleType: V, printIndexedAccessType: j, printJSDocType: Y } = Or();
                        function ie(ee, ce, W) {
                            let K = ee.getValue();
                            if (!K.type.startsWith("TS")) return;
                            if (w(K)) return K.type.slice(2, -7).toLowerCase();
                            let de = ce.semi ? ";" : "", ue = [];
                            switch(K.type){
                                case "TSThisType":
                                    return "this";
                                case "TSTypeAssertion":
                                    {
                                        let Fe = !(K.expression.type === "ArrayExpression" || K.expression.type === "ObjectExpression"), z = l([
                                            "<",
                                            p([
                                                i,
                                                W("typeAnnotation")
                                            ]),
                                            i,
                                            ">"
                                        ]), U = [
                                            h("("),
                                            p([
                                                i,
                                                W("expression")
                                            ]),
                                            i,
                                            h(")")
                                        ];
                                        return Fe ? y([
                                            [
                                                z,
                                                W("expression")
                                            ],
                                            [
                                                z,
                                                l(U, {
                                                    shouldBreak: true
                                                })
                                            ],
                                            [
                                                z,
                                                W("expression")
                                            ]
                                        ]) : l([
                                            z,
                                            W("expression")
                                        ]);
                                    }
                                case "TSDeclareFunction":
                                    return B(ee, W, ce);
                                case "TSExportAssignment":
                                    return [
                                        "export = ",
                                        W("expression"),
                                        de
                                    ];
                                case "TSModuleBlock":
                                    return R(ee, ce, W);
                                case "TSInterfaceBody":
                                case "TSTypeLiteral":
                                    return C(ee, ce, W);
                                case "TSTypeAliasDeclaration":
                                    return q(ee, ce, W);
                                case "TSQualifiedName":
                                    return a2(".", [
                                        W("left"),
                                        W("right")
                                    ]);
                                case "TSAbstractMethodDefinition":
                                case "TSDeclareMethod":
                                    return d(ee, ce, W);
                                case "TSAbstractAccessorProperty":
                                case "TSAbstractPropertyDefinition":
                                    return o(ee, ce, W);
                                case "TSInterfaceHeritage":
                                case "TSExpressionWithTypeArguments":
                                    return ue.push(W("expression")), K.typeParameters && ue.push(W("typeParameters")), ue;
                                case "TSTemplateLiteralType":
                                    return T(ee, W, ce);
                                case "TSNamedTupleMember":
                                    return [
                                        W("label"),
                                        K.optional ? "?" : "",
                                        ": ",
                                        W("elementType")
                                    ];
                                case "TSRestType":
                                    return [
                                        "...",
                                        W("typeAnnotation")
                                    ];
                                case "TSOptionalType":
                                    return [
                                        W("typeAnnotation"),
                                        "?"
                                    ];
                                case "TSInterfaceDeclaration":
                                    return M(ee, ce, W);
                                case "TSClassImplements":
                                    return [
                                        W("expression"),
                                        W("typeParameters")
                                    ];
                                case "TSTypeParameterDeclaration":
                                case "TSTypeParameterInstantiation":
                                    return S(ee, ce, W, "params");
                                case "TSTypeParameter":
                                    return v(ee, ce, W);
                                case "TSSatisfiesExpression":
                                case "TSAsExpression":
                                    {
                                        let Fe = K.type === "TSAsExpression" ? "as" : "satisfies";
                                        ue.push(W("expression"), ` ${Fe} `, W("typeAnnotation"));
                                        let z = ee.getParentNode();
                                        return F(z) && z.callee === K || _2(z) && z.object === K ? l([
                                            p([
                                                i,
                                                ...ue
                                            ]),
                                            i
                                        ]) : ue;
                                    }
                                case "TSArrayType":
                                    return [
                                        W("elementType"),
                                        "[]"
                                    ];
                                case "TSPropertySignature":
                                    return K.readonly && ue.push("readonly "), ue.push(b(ee, ce, W), x(ee)), K.typeAnnotation && ue.push(": ", W("typeAnnotation")), K.initializer && ue.push(" = ", W("initializer")), ue;
                                case "TSParameterProperty":
                                    return K.accessibility && ue.push(K.accessibility + " "), K.export && ue.push("export "), K.static && ue.push("static "), K.override && ue.push("override "), K.readonly && ue.push("readonly "), ue.push(W("parameter")), ue;
                                case "TSTypeQuery":
                                    return [
                                        "typeof ",
                                        W("exprName"),
                                        W("typeParameters")
                                    ];
                                case "TSIndexSignature":
                                    {
                                        let Fe = ee.getParentNode(), z = K.parameters.length > 1 ? h(f2(ce) ? "," : "") : "", U = l([
                                            p([
                                                i,
                                                a2([
                                                    ", ",
                                                    i
                                                ], ee.map(W, "parameters"))
                                            ]),
                                            z,
                                            i
                                        ]);
                                        return [
                                            K.export ? "export " : "",
                                            K.accessibility ? [
                                                K.accessibility,
                                                " "
                                            ] : "",
                                            K.static ? "static " : "",
                                            K.readonly ? "readonly " : "",
                                            K.declare ? "declare " : "",
                                            "[",
                                            K.parameters ? U : "",
                                            K.typeAnnotation ? "]: " : "]",
                                            K.typeAnnotation ? W("typeAnnotation") : "",
                                            Fe.type === "ClassBody" ? de : ""
                                        ];
                                    }
                                case "TSTypePredicate":
                                    return [
                                        K.asserts ? "asserts " : "",
                                        W("parameterName"),
                                        K.typeAnnotation ? [
                                            " is ",
                                            W("typeAnnotation")
                                        ] : ""
                                    ];
                                case "TSNonNullExpression":
                                    return [
                                        W("expression"),
                                        "!"
                                    ];
                                case "TSImportType":
                                    return [
                                        K.isTypeOf ? "typeof " : "",
                                        "import(",
                                        W(K.parameter ? "parameter" : "argument"),
                                        ")",
                                        K.qualifier ? [
                                            ".",
                                            W("qualifier")
                                        ] : "",
                                        S(ee, ce, W, "typeParameters")
                                    ];
                                case "TSLiteralType":
                                    return W("literal");
                                case "TSIndexedAccessType":
                                    return j(ee, ce, W);
                                case "TSConstructSignatureDeclaration":
                                case "TSCallSignatureDeclaration":
                                case "TSConstructorType":
                                    {
                                        if (K.type === "TSConstructorType" && K.abstract && ue.push("abstract "), K.type !== "TSCallSignatureDeclaration" && ue.push("new "), ue.push(l($(ee, W, ce, false, true))), K.returnType || K.typeAnnotation) {
                                            let Fe = K.type === "TSConstructorType";
                                            ue.push(Fe ? " => " : ": ", W("returnType"), W("typeAnnotation"));
                                        }
                                        return ue;
                                    }
                                case "TSTypeOperator":
                                    return [
                                        K.operator,
                                        " ",
                                        W("typeAnnotation")
                                    ];
                                case "TSMappedType":
                                    {
                                        let Fe = s(ce.originalText, E(K), N(K));
                                        return l([
                                            "{",
                                            p([
                                                ce.bracketSpacing ? n : i,
                                                W("typeParameter"),
                                                K.optional ? c(K.optional, "?") : "",
                                                K.typeAnnotation ? ": " : "",
                                                W("typeAnnotation"),
                                                h(de)
                                            ]),
                                            t1(ee, ce, true),
                                            ce.bracketSpacing ? n : i,
                                            "}"
                                        ], {
                                            shouldBreak: Fe
                                        });
                                    }
                                case "TSMethodSignature":
                                    {
                                        let Fe = K.kind && K.kind !== "method" ? `${K.kind} ` : "";
                                        ue.push(K.accessibility ? [
                                            K.accessibility,
                                            " "
                                        ] : "", Fe, K.export ? "export " : "", K.static ? "static " : "", K.readonly ? "readonly " : "", K.abstract ? "abstract " : "", K.declare ? "declare " : "", K.computed ? "[" : "", W("key"), K.computed ? "]" : "", x(ee));
                                        let z = $(ee, W, ce, false, true), U = K.returnType ? "returnType" : "typeAnnotation", Z = K[U], se = Z ? W(U) : "", fe = D(K, se);
                                        return ue.push(fe ? l(z) : z), Z && ue.push(": ", l(se)), l(ue);
                                    }
                                case "TSNamespaceExportDeclaration":
                                    return ue.push("export as namespace ", W("id")), ce.semi && ue.push(";"), l(ue);
                                case "TSEnumDeclaration":
                                    return K.declare && ue.push("declare "), K.modifiers && ue.push(I(ee, ce, W)), K.const && ue.push("const "), ue.push("enum ", W("id"), " "), K.members.length === 0 ? ue.push(l([
                                        "{",
                                        t1(ee, ce),
                                        i,
                                        "}"
                                    ])) : ue.push(l([
                                        "{",
                                        p([
                                            u,
                                            m(ee, ce, "members", W),
                                            f2(ce, "es5") ? "," : ""
                                        ]),
                                        t1(ee, ce, true),
                                        u,
                                        "}"
                                    ])), ue;
                                case "TSEnumMember":
                                    return K.computed ? ue.push("[", W("id"), "]") : ue.push(W("id")), K.initializer && ue.push(" = ", W("initializer")), ue;
                                case "TSImportEqualsDeclaration":
                                    return K.isExport && ue.push("export "), ue.push("import "), K.importKind && K.importKind !== "value" && ue.push(K.importKind, " "), ue.push(W("id"), " = ", W("moduleReference")), ce.semi && ue.push(";"), l(ue);
                                case "TSExternalModuleReference":
                                    return [
                                        "require(",
                                        W("expression"),
                                        ")"
                                    ];
                                case "TSModuleDeclaration":
                                    {
                                        let Fe = ee.getParentNode(), z = g(K.id), U = Fe.type === "TSModuleDeclaration", Z = K.body && K.body.type === "TSModuleDeclaration";
                                        if (U) ue.push(".");
                                        else {
                                            K.declare && ue.push("declare "), ue.push(I(ee, ce, W));
                                            let se = ce.originalText.slice(E(K), E(K.id));
                                            K.id.type === "Identifier" && K.id.name === "global" && !/namespace|module/.test(se) || ue.push(z || /(?:^|\s)module(?:\s|$)/.test(se) ? "module " : "namespace ");
                                        }
                                        return ue.push(W("id")), Z ? ue.push(W("body")) : K.body ? ue.push(" ", l(W("body"))) : ue.push(de), ue;
                                    }
                                case "TSConditionalType":
                                    return P(ee, ce, W);
                                case "TSInferType":
                                    return [
                                        "infer",
                                        " ",
                                        W("typeParameter")
                                    ];
                                case "TSIntersectionType":
                                    return J(ee, ce, W);
                                case "TSUnionType":
                                    return L(ee, ce, W);
                                case "TSFunctionType":
                                    return Q(ee, ce, W);
                                case "TSTupleType":
                                    return V(ee, ce, W);
                                case "TSTypeReference":
                                    return [
                                        W("typeName"),
                                        S(ee, ce, W, "typeParameters")
                                    ];
                                case "TSTypeAnnotation":
                                    return W("typeAnnotation");
                                case "TSEmptyBodyFunctionExpression":
                                    return k(ee, ce, W);
                                case "TSJSDocAllType":
                                    return "*";
                                case "TSJSDocUnknownType":
                                    return "?";
                                case "TSJSDocNullableType":
                                    return Y(ee, W, "?");
                                case "TSJSDocNonNullableType":
                                    return Y(ee, W, "!");
                                case "TSInstantiationExpression":
                                    return [
                                        W("expression"),
                                        W("typeParameters")
                                    ];
                                default:
                                    throw new Error(`Unknown TypeScript node type: ${JSON.stringify(K.type)}.`);
                            }
                        }
                        r.exports = {
                            printTypescript: ie
                        };
                    }
                }), hd = te({
                    "src/language-js/print/comment.js" (e, r) {
                        "use strict";
                        ne();
                        var { hasNewline: t1 } = Ue(), { builders: { join: s, hardline: a2 }, utils: { replaceTextEndOfLine: n } } = qe(), { isLineComment: u } = Ke(), { locStart: i, locEnd: l } = ut(), p = Pt();
                        function y(c, f2) {
                            let F = c.getValue();
                            if (u(F)) return f2.originalText.slice(i(F), l(F)).trimEnd();
                            if (p(F)) {
                                if (h(F)) {
                                    let E = g(F);
                                    return F.trailing && !t1(f2.originalText, i(F), {
                                        backwards: true
                                    }) ? [
                                        a2,
                                        E
                                    ] : E;
                                }
                                let _2 = l(F), w = f2.originalText.slice(_2 - 3, _2) === "*-/";
                                return [
                                    "/*",
                                    n(F.value),
                                    w ? "*-/" : "*/"
                                ];
                            }
                            throw new Error("Not a comment: " + JSON.stringify(F));
                        }
                        function h(c) {
                            let f2 = `*${c.value}*`.split(`
`);
                            return f2.length > 1 && f2.every((F)=>F.trim()[0] === "*");
                        }
                        function g(c) {
                            let f2 = c.value.split(`
`);
                            return [
                                "/*",
                                s(a2, f2.map((F, _2)=>_2 === 0 ? F.trimEnd() : " " + (_2 < f2.length - 1 ? F.trim() : F.trimStart()))),
                                "*/"
                            ];
                        }
                        r.exports = {
                            printComment: y
                        };
                    }
                }), vd = te({
                    "src/language-js/print/literal.js" (e, r) {
                        "use strict";
                        ne();
                        var { printString: t1, printNumber: s } = Ue(), { replaceTextEndOfLine: a2 } = Yt(), { printDirective: n } = ct();
                        function u(y, h) {
                            let g = y.getNode();
                            switch(g.type){
                                case "RegExpLiteral":
                                    return p(g);
                                case "BigIntLiteral":
                                    return l(g.bigint || g.extra.raw);
                                case "NumericLiteral":
                                    return s(g.extra.raw);
                                case "StringLiteral":
                                    return a2(t1(g.extra.raw, h));
                                case "NullLiteral":
                                    return "null";
                                case "BooleanLiteral":
                                    return String(g.value);
                                case "DecimalLiteral":
                                    return s(g.value) + "m";
                                case "Literal":
                                    {
                                        if (g.regex) return p(g.regex);
                                        if (g.bigint) return l(g.raw);
                                        if (g.decimal) return s(g.decimal) + "m";
                                        let { value: c } = g;
                                        return typeof c == "number" ? s(g.raw) : typeof c == "string" ? i(y) ? n(g.raw, h) : a2(t1(g.raw, h)) : String(c);
                                    }
                            }
                        }
                        function i(y) {
                            if (y.getName() !== "expression") return;
                            let h = y.getParentNode();
                            return h.type === "ExpressionStatement" && h.directive;
                        }
                        function l(y) {
                            return y.toLowerCase();
                        }
                        function p(y) {
                            let { pattern: h, flags: g } = y;
                            return g = [
                                ...g
                            ].sort().join(""), `/${h}/${g}`;
                        }
                        r.exports = {
                            printLiteral: u
                        };
                    }
                }), Cd = te({
                    "src/language-js/printer-estree.js" (e, r) {
                        "use strict";
                        ne();
                        var { printDanglingComments: t1 } = et(), { hasNewline: s } = Ue(), { builders: { join: a2, line: n, hardline: u, softline: i, group: l, indent: p }, utils: { replaceTextEndOfLine: y } } = qe(), h = td(), g = rd(), { insertPragma: c } = Co(), f2 = Eo(), F = qt(), _2 = Fo(), { hasFlowShorthandAnnotationComment: w, hasComment: E, CommentCheckFlags: N, isTheOnlyJsxElementInMarkdown: x, isLineComment: I, isNextLineEmpty: P, needsHardlineAfterDanglingComment: $, hasIgnoreComment: D, isCallExpression: T, isMemberExpression: m, markerForIfWithoutBlockAndSameLineComment: C } = Ke(), { locStart: o, locEnd: d } = ut(), v = Pt(), { printHtmlBinding: S, isVueEventBindingExpression: b } = pd(), { printAngular: B } = fd(), { printJsx: k, hasJsxIgnoreComment: M } = Dd(), { printFlow: R } = dd(), { printTypescript: q } = yd(), { printOptionalToken: J, printBindExpressionCallee: L, printTypeAnnotation: Q, adjustClause: V, printRestSpread: j, printDefiniteToken: Y, printDirective: ie } = ct(), { printImportDeclaration: ee, printExportDeclaration: ce, printExportAllDeclaration: W, printModuleSpecifier: K } = To(), { printTernary: de } = Bo(), { printTemplateLiteral: ue } = jt(), { printArray: Fe } = er(), { printObject: z } = uu(), { printClass: U, printClassMethod: Z, printClassProperty: se } = nr(), { printProperty: fe } = rr(), { printFunction: ge, printArrowFunction: he, printMethod: we, printReturnStatement: ke, printThrowStatement: Re } = qr(), { printCallExpression: Ne } = xo(), { printVariableDeclarator: Pe, printAssignmentExpression: oe } = tr(), { printBinaryishExpression: H } = ru(), { printSwitchCaseConsequent: pe } = No(), { printMemberExpression: X } = So(), { printBlock: le, printBlockBody: Ae } = wo(), { printComment: Ee } = hd(), { printLiteral: De } = vd(), { printDecorators: A2 } = nu();
                        function G(Ce, Be, ve, ze) {
                            let be = re(Ce, Be, ve, ze);
                            if (!be) return "";
                            let Ye = Ce.getValue(), { type: Se } = Ye;
                            if (Se === "ClassMethod" || Se === "ClassPrivateMethod" || Se === "ClassProperty" || Se === "ClassAccessorProperty" || Se === "AccessorProperty" || Se === "TSAbstractAccessorProperty" || Se === "PropertyDefinition" || Se === "TSAbstractPropertyDefinition" || Se === "ClassPrivateProperty" || Se === "MethodDefinition" || Se === "TSAbstractMethodDefinition" || Se === "TSDeclareMethod") return be;
                            let Ie = [
                                be
                            ], Oe = A2(Ce, Be, ve), Je = Ye.type === "ClassExpression" && Oe;
                            if (Oe && (Ie = [
                                ...Oe,
                                be
                            ], !Je)) return l(Ie);
                            if (!F(Ce, Be)) return ze && ze.needsSemi && Ie.unshift(";"), Ie.length === 1 && Ie[0] === be ? be : Ie;
                            if (Je && (Ie = [
                                p([
                                    n,
                                    ...Ie
                                ])
                            ]), Ie.unshift("("), ze && ze.needsSemi && Ie.unshift(";"), w(Ye)) {
                                let [je] = Ye.trailingComments;
                                Ie.push(" /*", je.value.trimStart(), "*/"), je.printed = true;
                            }
                            return Je && Ie.push(n), Ie.push(")"), Ie;
                        }
                        function re(Ce, Be, ve, ze) {
                            let be = Ce.getValue(), Ye = Be.semi ? ";" : "";
                            if (!be) return "";
                            if (typeof be == "string") return be;
                            for (let Ie of [
                                De,
                                S,
                                B,
                                k,
                                R,
                                q
                            ]){
                                let Oe = Ie(Ce, Be, ve);
                                if (typeof Oe < "u") return Oe;
                            }
                            let Se = [];
                            switch(be.type){
                                case "JsExpressionRoot":
                                    return ve("node");
                                case "JsonRoot":
                                    return [
                                        ve("node"),
                                        u
                                    ];
                                case "File":
                                    return be.program && be.program.interpreter && Se.push(ve([
                                        "program",
                                        "interpreter"
                                    ])), Se.push(ve("program")), Se;
                                case "Program":
                                    return Ae(Ce, Be, ve);
                                case "EmptyStatement":
                                    return "";
                                case "ExpressionStatement":
                                    {
                                        if (Be.parser === "__vue_event_binding" || Be.parser === "__vue_ts_event_binding") {
                                            let Oe = Ce.getParentNode();
                                            if (Oe.type === "Program" && Oe.body.length === 1 && Oe.body[0] === be) return [
                                                ve("expression"),
                                                b(be.expression) ? ";" : ""
                                            ];
                                        }
                                        let Ie = t1(Ce, Be, true, (Oe)=>{
                                            let { marker: Je } = Oe;
                                            return Je === C;
                                        });
                                        return [
                                            ve("expression"),
                                            x(Be, Ce) ? "" : Ye,
                                            Ie ? [
                                                " ",
                                                Ie
                                            ] : ""
                                        ];
                                    }
                                case "ParenthesizedExpression":
                                    return !E(be.expression) && (be.expression.type === "ObjectExpression" || be.expression.type === "ArrayExpression") ? [
                                        "(",
                                        ve("expression"),
                                        ")"
                                    ] : l([
                                        "(",
                                        p([
                                            i,
                                            ve("expression")
                                        ]),
                                        i,
                                        ")"
                                    ]);
                                case "AssignmentExpression":
                                    return oe(Ce, Be, ve);
                                case "VariableDeclarator":
                                    return Pe(Ce, Be, ve);
                                case "BinaryExpression":
                                case "LogicalExpression":
                                    return H(Ce, Be, ve);
                                case "AssignmentPattern":
                                    return [
                                        ve("left"),
                                        " = ",
                                        ve("right")
                                    ];
                                case "OptionalMemberExpression":
                                case "MemberExpression":
                                    return X(Ce, Be, ve);
                                case "MetaProperty":
                                    return [
                                        ve("meta"),
                                        ".",
                                        ve("property")
                                    ];
                                case "BindExpression":
                                    return be.object && Se.push(ve("object")), Se.push(l(p([
                                        i,
                                        L(Ce, Be, ve)
                                    ]))), Se;
                                case "Identifier":
                                    return [
                                        be.name,
                                        J(Ce),
                                        Y(Ce),
                                        Q(Ce, Be, ve)
                                    ];
                                case "V8IntrinsicIdentifier":
                                    return [
                                        "%",
                                        be.name
                                    ];
                                case "SpreadElement":
                                case "SpreadElementPattern":
                                case "SpreadProperty":
                                case "SpreadPropertyPattern":
                                case "RestElement":
                                    return j(Ce, Be, ve);
                                case "FunctionDeclaration":
                                case "FunctionExpression":
                                    return ge(Ce, ve, Be, ze);
                                case "ArrowFunctionExpression":
                                    return he(Ce, Be, ve, ze);
                                case "YieldExpression":
                                    return Se.push("yield"), be.delegate && Se.push("*"), be.argument && Se.push(" ", ve("argument")), Se;
                                case "AwaitExpression":
                                    {
                                        if (Se.push("await"), be.argument) {
                                            Se.push(" ", ve("argument"));
                                            let Ie = Ce.getParentNode();
                                            if (T(Ie) && Ie.callee === be || m(Ie) && Ie.object === be) {
                                                Se = [
                                                    p([
                                                        i,
                                                        ...Se
                                                    ]),
                                                    i
                                                ];
                                                let Oe = Ce.findAncestor((Je)=>Je.type === "AwaitExpression" || Je.type === "BlockStatement");
                                                if (!Oe || Oe.type !== "AwaitExpression") return l(Se);
                                            }
                                        }
                                        return Se;
                                    }
                                case "ExportDefaultDeclaration":
                                case "ExportNamedDeclaration":
                                    return ce(Ce, Be, ve);
                                case "ExportAllDeclaration":
                                    return W(Ce, Be, ve);
                                case "ImportDeclaration":
                                    return ee(Ce, Be, ve);
                                case "ImportSpecifier":
                                case "ExportSpecifier":
                                case "ImportNamespaceSpecifier":
                                case "ExportNamespaceSpecifier":
                                case "ImportDefaultSpecifier":
                                case "ExportDefaultSpecifier":
                                    return K(Ce, Be, ve);
                                case "ImportAttribute":
                                    return [
                                        ve("key"),
                                        ": ",
                                        ve("value")
                                    ];
                                case "Import":
                                    return "import";
                                case "BlockStatement":
                                case "StaticBlock":
                                case "ClassBody":
                                    return le(Ce, Be, ve);
                                case "ThrowStatement":
                                    return Re(Ce, Be, ve);
                                case "ReturnStatement":
                                    return ke(Ce, Be, ve);
                                case "NewExpression":
                                case "ImportExpression":
                                case "OptionalCallExpression":
                                case "CallExpression":
                                    return Ne(Ce, Be, ve);
                                case "ObjectExpression":
                                case "ObjectPattern":
                                case "RecordExpression":
                                    return z(Ce, Be, ve);
                                case "ObjectProperty":
                                case "Property":
                                    return be.method || be.kind === "get" || be.kind === "set" ? we(Ce, Be, ve) : fe(Ce, Be, ve);
                                case "ObjectMethod":
                                    return we(Ce, Be, ve);
                                case "Decorator":
                                    return [
                                        "@",
                                        ve("expression")
                                    ];
                                case "ArrayExpression":
                                case "ArrayPattern":
                                case "TupleExpression":
                                    return Fe(Ce, Be, ve);
                                case "SequenceExpression":
                                    {
                                        let Ie = Ce.getParentNode(0);
                                        if (Ie.type === "ExpressionStatement" || Ie.type === "ForStatement") {
                                            let Oe = [];
                                            return Ce.each((Je, Te)=>{
                                                Te === 0 ? Oe.push(ve()) : Oe.push(",", p([
                                                    n,
                                                    ve()
                                                ]));
                                            }, "expressions"), l(Oe);
                                        }
                                        return l(a2([
                                            ",",
                                            n
                                        ], Ce.map(ve, "expressions")));
                                    }
                                case "ThisExpression":
                                    return "this";
                                case "Super":
                                    return "super";
                                case "Directive":
                                    return [
                                        ve("value"),
                                        Ye
                                    ];
                                case "DirectiveLiteral":
                                    return ie(be.extra.raw, Be);
                                case "UnaryExpression":
                                    return Se.push(be.operator), /[a-z]$/.test(be.operator) && Se.push(" "), E(be.argument) ? Se.push(l([
                                        "(",
                                        p([
                                            i,
                                            ve("argument")
                                        ]),
                                        i,
                                        ")"
                                    ])) : Se.push(ve("argument")), Se;
                                case "UpdateExpression":
                                    return Se.push(ve("argument"), be.operator), be.prefix && Se.reverse(), Se;
                                case "ConditionalExpression":
                                    return de(Ce, Be, ve);
                                case "VariableDeclaration":
                                    {
                                        let Ie = Ce.map(ve, "declarations"), Oe = Ce.getParentNode(), Je = Oe.type === "ForStatement" || Oe.type === "ForInStatement" || Oe.type === "ForOfStatement", Te = be.declarations.some((Me)=>Me.init), je;
                                        return Ie.length === 1 && !E(be.declarations[0]) ? je = Ie[0] : Ie.length > 0 && (je = p(Ie[0])), Se = [
                                            be.declare ? "declare " : "",
                                            be.kind,
                                            je ? [
                                                " ",
                                                je
                                            ] : "",
                                            p(Ie.slice(1).map((Me)=>[
                                                    ",",
                                                    Te && !Je ? u : n,
                                                    Me
                                                ]))
                                        ], Je && Oe.body !== be || Se.push(Ye), l(Se);
                                    }
                                case "WithStatement":
                                    return l([
                                        "with (",
                                        ve("object"),
                                        ")",
                                        V(be.body, ve("body"))
                                    ]);
                                case "IfStatement":
                                    {
                                        let Ie = V(be.consequent, ve("consequent")), Oe = l([
                                            "if (",
                                            l([
                                                p([
                                                    i,
                                                    ve("test")
                                                ]),
                                                i
                                            ]),
                                            ")",
                                            Ie
                                        ]);
                                        if (Se.push(Oe), be.alternate) {
                                            let Je = E(be.consequent, N.Trailing | N.Line) || $(be), Te = be.consequent.type === "BlockStatement" && !Je;
                                            Se.push(Te ? " " : u), E(be, N.Dangling) && Se.push(t1(Ce, Be, true), Je ? u : " "), Se.push("else", l(V(be.alternate, ve("alternate"), be.alternate.type === "IfStatement")));
                                        }
                                        return Se;
                                    }
                                case "ForStatement":
                                    {
                                        let Ie = V(be.body, ve("body")), Oe = t1(Ce, Be, true), Je = Oe ? [
                                            Oe,
                                            i
                                        ] : "";
                                        return !be.init && !be.test && !be.update ? [
                                            Je,
                                            l([
                                                "for (;;)",
                                                Ie
                                            ])
                                        ] : [
                                            Je,
                                            l([
                                                "for (",
                                                l([
                                                    p([
                                                        i,
                                                        ve("init"),
                                                        ";",
                                                        n,
                                                        ve("test"),
                                                        ";",
                                                        n,
                                                        ve("update")
                                                    ]),
                                                    i
                                                ]),
                                                ")",
                                                Ie
                                            ])
                                        ];
                                    }
                                case "WhileStatement":
                                    return l([
                                        "while (",
                                        l([
                                            p([
                                                i,
                                                ve("test")
                                            ]),
                                            i
                                        ]),
                                        ")",
                                        V(be.body, ve("body"))
                                    ]);
                                case "ForInStatement":
                                    return l([
                                        "for (",
                                        ve("left"),
                                        " in ",
                                        ve("right"),
                                        ")",
                                        V(be.body, ve("body"))
                                    ]);
                                case "ForOfStatement":
                                    return l([
                                        "for",
                                        be.await ? " await" : "",
                                        " (",
                                        ve("left"),
                                        " of ",
                                        ve("right"),
                                        ")",
                                        V(be.body, ve("body"))
                                    ]);
                                case "DoWhileStatement":
                                    {
                                        let Ie = V(be.body, ve("body"));
                                        return Se = [
                                            l([
                                                "do",
                                                Ie
                                            ])
                                        ], be.body.type === "BlockStatement" ? Se.push(" ") : Se.push(u), Se.push("while (", l([
                                            p([
                                                i,
                                                ve("test")
                                            ]),
                                            i
                                        ]), ")", Ye), Se;
                                    }
                                case "DoExpression":
                                    return [
                                        be.async ? "async " : "",
                                        "do ",
                                        ve("body")
                                    ];
                                case "BreakStatement":
                                    return Se.push("break"), be.label && Se.push(" ", ve("label")), Se.push(Ye), Se;
                                case "ContinueStatement":
                                    return Se.push("continue"), be.label && Se.push(" ", ve("label")), Se.push(Ye), Se;
                                case "LabeledStatement":
                                    return be.body.type === "EmptyStatement" ? [
                                        ve("label"),
                                        ":;"
                                    ] : [
                                        ve("label"),
                                        ": ",
                                        ve("body")
                                    ];
                                case "TryStatement":
                                    return [
                                        "try ",
                                        ve("block"),
                                        be.handler ? [
                                            " ",
                                            ve("handler")
                                        ] : "",
                                        be.finalizer ? [
                                            " finally ",
                                            ve("finalizer")
                                        ] : ""
                                    ];
                                case "CatchClause":
                                    if (be.param) {
                                        let Ie = E(be.param, (Je)=>!v(Je) || Je.leading && s(Be.originalText, d(Je)) || Je.trailing && s(Be.originalText, o(Je), {
                                                backwards: true
                                            })), Oe = ve("param");
                                        return [
                                            "catch ",
                                            Ie ? [
                                                "(",
                                                p([
                                                    i,
                                                    Oe
                                                ]),
                                                i,
                                                ") "
                                            ] : [
                                                "(",
                                                Oe,
                                                ") "
                                            ],
                                            ve("body")
                                        ];
                                    }
                                    return [
                                        "catch ",
                                        ve("body")
                                    ];
                                case "SwitchStatement":
                                    return [
                                        l([
                                            "switch (",
                                            p([
                                                i,
                                                ve("discriminant")
                                            ]),
                                            i,
                                            ")"
                                        ]),
                                        " {",
                                        be.cases.length > 0 ? p([
                                            u,
                                            a2(u, Ce.map((Ie, Oe, Je)=>{
                                                let Te = Ie.getValue();
                                                return [
                                                    ve(),
                                                    Oe !== Je.length - 1 && P(Te, Be) ? u : ""
                                                ];
                                            }, "cases"))
                                        ]) : "",
                                        u,
                                        "}"
                                    ];
                                case "SwitchCase":
                                    {
                                        be.test ? Se.push("case ", ve("test"), ":") : Se.push("default:"), E(be, N.Dangling) && Se.push(" ", t1(Ce, Be, true));
                                        let Ie = be.consequent.filter((Oe)=>Oe.type !== "EmptyStatement");
                                        if (Ie.length > 0) {
                                            let Oe = pe(Ce, Be, ve);
                                            Se.push(Ie.length === 1 && Ie[0].type === "BlockStatement" ? [
                                                " ",
                                                Oe
                                            ] : p([
                                                u,
                                                Oe
                                            ]));
                                        }
                                        return Se;
                                    }
                                case "DebuggerStatement":
                                    return [
                                        "debugger",
                                        Ye
                                    ];
                                case "ClassDeclaration":
                                case "ClassExpression":
                                    return U(Ce, Be, ve);
                                case "ClassMethod":
                                case "ClassPrivateMethod":
                                case "MethodDefinition":
                                    return Z(Ce, Be, ve);
                                case "ClassProperty":
                                case "PropertyDefinition":
                                case "ClassPrivateProperty":
                                case "ClassAccessorProperty":
                                case "AccessorProperty":
                                    return se(Ce, Be, ve);
                                case "TemplateElement":
                                    return y(be.value.raw);
                                case "TemplateLiteral":
                                    return ue(Ce, ve, Be);
                                case "TaggedTemplateExpression":
                                    return [
                                        ve("tag"),
                                        ve("typeParameters"),
                                        ve("quasi")
                                    ];
                                case "PrivateIdentifier":
                                    return [
                                        "#",
                                        ve("name")
                                    ];
                                case "PrivateName":
                                    return [
                                        "#",
                                        ve("id")
                                    ];
                                case "InterpreterDirective":
                                    return Se.push("#!", be.value, u), P(be, Be) && Se.push(u), Se;
                                case "TopicReference":
                                    return "%";
                                case "ArgumentPlaceholder":
                                    return "?";
                                case "ModuleExpression":
                                    {
                                        Se.push("module {");
                                        let Ie = ve("body");
                                        return Ie && Se.push(p([
                                            u,
                                            Ie
                                        ]), u), Se.push("}"), Se;
                                    }
                                default:
                                    throw new Error("unknown type: " + JSON.stringify(be.type));
                            }
                        }
                        function ye(Ce) {
                            return Ce.type && !v(Ce) && !I(Ce) && Ce.type !== "EmptyStatement" && Ce.type !== "TemplateElement" && Ce.type !== "Import" && Ce.type !== "TSEmptyBodyFunctionExpression";
                        }
                        r.exports = {
                            preprocess: _2,
                            print: G,
                            embed: h,
                            insertPragma: c,
                            massageAstNode: g,
                            hasPrettierIgnore (Ce) {
                                return D(Ce) || M(Ce);
                            },
                            willPrintOwnComments: f2.willPrintOwnComments,
                            canAttachComment: ye,
                            printComment: Ee,
                            isBlockComment: v,
                            handleComments: {
                                avoidAstMutation: true,
                                ownLine: f2.handleOwnLineComment,
                                endOfLine: f2.handleEndOfLineComment,
                                remaining: f2.handleRemainingComment
                            },
                            getCommentChildNodes: f2.getCommentChildNodes
                        };
                    }
                }), Ed = te({
                    "src/language-js/printer-estree-json.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { hardline: t1, indent: s, join: a2 } } = qe(), n = Fo();
                        function u(y, h, g) {
                            let c = y.getValue();
                            switch(c.type){
                                case "JsonRoot":
                                    return [
                                        g("node"),
                                        t1
                                    ];
                                case "ArrayExpression":
                                    {
                                        if (c.elements.length === 0) return "[]";
                                        let f2 = y.map(()=>y.getValue() === null ? "null" : g(), "elements");
                                        return [
                                            "[",
                                            s([
                                                t1,
                                                a2([
                                                    ",",
                                                    t1
                                                ], f2)
                                            ]),
                                            t1,
                                            "]"
                                        ];
                                    }
                                case "ObjectExpression":
                                    return c.properties.length === 0 ? "{}" : [
                                        "{",
                                        s([
                                            t1,
                                            a2([
                                                ",",
                                                t1
                                            ], y.map(g, "properties"))
                                        ]),
                                        t1,
                                        "}"
                                    ];
                                case "ObjectProperty":
                                    return [
                                        g("key"),
                                        ": ",
                                        g("value")
                                    ];
                                case "UnaryExpression":
                                    return [
                                        c.operator === "+" ? "" : c.operator,
                                        g("argument")
                                    ];
                                case "NullLiteral":
                                    return "null";
                                case "BooleanLiteral":
                                    return c.value ? "true" : "false";
                                case "StringLiteral":
                                    return JSON.stringify(c.value);
                                case "NumericLiteral":
                                    return i(y) ? JSON.stringify(String(c.value)) : JSON.stringify(c.value);
                                case "Identifier":
                                    return i(y) ? JSON.stringify(c.name) : c.name;
                                case "TemplateLiteral":
                                    return g([
                                        "quasis",
                                        0
                                    ]);
                                case "TemplateElement":
                                    return JSON.stringify(c.value.cooked);
                                default:
                                    throw new Error("unknown type: " + JSON.stringify(c.type));
                            }
                        }
                        function i(y) {
                            return y.getName() === "key" && y.getParentNode().type === "ObjectProperty";
                        }
                        var l = /* @__PURE__ */ new Set([
                            "start",
                            "end",
                            "extra",
                            "loc",
                            "comments",
                            "leadingComments",
                            "trailingComments",
                            "innerComments",
                            "errors",
                            "range",
                            "tokens"
                        ]);
                        function p(y, h) {
                            let { type: g } = y;
                            if (g === "ObjectProperty") {
                                let { key: c } = y;
                                c.type === "Identifier" ? h.key = {
                                    type: "StringLiteral",
                                    value: c.name
                                } : c.type === "NumericLiteral" && (h.key = {
                                    type: "StringLiteral",
                                    value: String(c.value)
                                });
                                return;
                            }
                            if (g === "UnaryExpression" && y.operator === "+") return h.argument;
                            if (g === "ArrayExpression") {
                                for (let [c, f2] of y.elements.entries())f2 === null && h.elements.splice(c, 0, {
                                    type: "NullLiteral"
                                });
                                return;
                            }
                            if (g === "TemplateLiteral") return {
                                type: "StringLiteral",
                                value: y.quasis[0].value.cooked
                            };
                        }
                        p.ignoredProperties = l, r.exports = {
                            preprocess: n,
                            print: u,
                            massageAstNode: p
                        };
                    }
                }), Mt = te({
                    "src/common/common-options.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = "Common";
                        r.exports = {
                            bracketSpacing: {
                                since: "0.0.0",
                                category: t1,
                                type: "boolean",
                                default: true,
                                description: "Print spaces between brackets.",
                                oppositeDescription: "Do not print spaces between brackets."
                            },
                            singleQuote: {
                                since: "0.0.0",
                                category: t1,
                                type: "boolean",
                                default: false,
                                description: "Use single quotes instead of double quotes."
                            },
                            proseWrap: {
                                since: "1.8.2",
                                category: t1,
                                type: "choice",
                                default: [
                                    {
                                        since: "1.8.2",
                                        value: true
                                    },
                                    {
                                        since: "1.9.0",
                                        value: "preserve"
                                    }
                                ],
                                description: "How to wrap prose.",
                                choices: [
                                    {
                                        since: "1.9.0",
                                        value: "always",
                                        description: "Wrap prose if it exceeds the print width."
                                    },
                                    {
                                        since: "1.9.0",
                                        value: "never",
                                        description: "Do not wrap prose."
                                    },
                                    {
                                        since: "1.9.0",
                                        value: "preserve",
                                        description: "Wrap prose as-is."
                                    }
                                ]
                            },
                            bracketSameLine: {
                                since: "2.4.0",
                                category: t1,
                                type: "boolean",
                                default: false,
                                description: "Put > of opening tags on the last line instead of on a new line."
                            },
                            singleAttributePerLine: {
                                since: "2.6.0",
                                category: t1,
                                type: "boolean",
                                default: false,
                                description: "Enforce single attribute per line in HTML, Vue and JSX."
                            }
                        };
                    }
                }), Fd = te({
                    "src/language-js/options.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Mt(), s = "JavaScript";
                        r.exports = {
                            arrowParens: {
                                since: "1.9.0",
                                category: s,
                                type: "choice",
                                default: [
                                    {
                                        since: "1.9.0",
                                        value: "avoid"
                                    },
                                    {
                                        since: "2.0.0",
                                        value: "always"
                                    }
                                ],
                                description: "Include parentheses around a sole arrow function parameter.",
                                choices: [
                                    {
                                        value: "always",
                                        description: "Always include parens. Example: `(x) => x`"
                                    },
                                    {
                                        value: "avoid",
                                        description: "Omit parens when possible. Example: `x => x`"
                                    }
                                ]
                            },
                            bracketSameLine: t1.bracketSameLine,
                            bracketSpacing: t1.bracketSpacing,
                            jsxBracketSameLine: {
                                since: "0.17.0",
                                category: s,
                                type: "boolean",
                                description: "Put > on the last line instead of at a new line.",
                                deprecated: "2.4.0"
                            },
                            semi: {
                                since: "1.0.0",
                                category: s,
                                type: "boolean",
                                default: true,
                                description: "Print semicolons.",
                                oppositeDescription: "Do not print semicolons, except at the beginning of lines which may need them."
                            },
                            singleQuote: t1.singleQuote,
                            jsxSingleQuote: {
                                since: "1.15.0",
                                category: s,
                                type: "boolean",
                                default: false,
                                description: "Use single quotes in JSX."
                            },
                            quoteProps: {
                                since: "1.17.0",
                                category: s,
                                type: "choice",
                                default: "as-needed",
                                description: "Change when properties in objects are quoted.",
                                choices: [
                                    {
                                        value: "as-needed",
                                        description: "Only add quotes around object properties where required."
                                    },
                                    {
                                        value: "consistent",
                                        description: "If at least one property in an object requires quotes, quote all properties."
                                    },
                                    {
                                        value: "preserve",
                                        description: "Respect the input use of quotes in object properties."
                                    }
                                ]
                            },
                            trailingComma: {
                                since: "0.0.0",
                                category: s,
                                type: "choice",
                                default: [
                                    {
                                        since: "0.0.0",
                                        value: false
                                    },
                                    {
                                        since: "0.19.0",
                                        value: "none"
                                    },
                                    {
                                        since: "2.0.0",
                                        value: "es5"
                                    }
                                ],
                                description: "Print trailing commas wherever possible when multi-line.",
                                choices: [
                                    {
                                        value: "es5",
                                        description: "Trailing commas where valid in ES5 (objects, arrays, etc.)"
                                    },
                                    {
                                        value: "none",
                                        description: "No trailing commas."
                                    },
                                    {
                                        value: "all",
                                        description: "Trailing commas wherever possible (including function arguments)."
                                    }
                                ]
                            },
                            singleAttributePerLine: t1.singleAttributePerLine
                        };
                    }
                }), Ad = te({
                    "src/language-js/parse/parsers.js" () {
                        ne();
                    }
                }), Ln = te({
                    "node_modules/linguist-languages/data/JavaScript.json" (e, r) {
                        r.exports = {
                            name: "JavaScript",
                            type: "programming",
                            tmScope: "source.js",
                            aceMode: "javascript",
                            codemirrorMode: "javascript",
                            codemirrorMimeType: "text/javascript",
                            color: "#f1e05a",
                            aliases: [
                                "js",
                                "node"
                            ],
                            extensions: [
                                ".js",
                                "._js",
                                ".bones",
                                ".cjs",
                                ".es",
                                ".es6",
                                ".frag",
                                ".gs",
                                ".jake",
                                ".javascript",
                                ".jsb",
                                ".jscad",
                                ".jsfl",
                                ".jslib",
                                ".jsm",
                                ".jspre",
                                ".jss",
                                ".jsx",
                                ".mjs",
                                ".njs",
                                ".pac",
                                ".sjs",
                                ".ssjs",
                                ".xsjs",
                                ".xsjslib"
                            ],
                            filenames: [
                                "Jakefile"
                            ],
                            interpreters: [
                                "chakra",
                                "d8",
                                "gjs",
                                "js",
                                "node",
                                "nodejs",
                                "qjs",
                                "rhino",
                                "v8",
                                "v8-shell"
                            ],
                            languageId: 183
                        };
                    }
                }), Sd = te({
                    "node_modules/linguist-languages/data/TypeScript.json" (e, r) {
                        r.exports = {
                            name: "TypeScript",
                            type: "programming",
                            color: "#3178c6",
                            aliases: [
                                "ts"
                            ],
                            interpreters: [
                                "deno",
                                "ts-node"
                            ],
                            extensions: [
                                ".ts",
                                ".cts",
                                ".mts"
                            ],
                            tmScope: "source.ts",
                            aceMode: "typescript",
                            codemirrorMode: "javascript",
                            codemirrorMimeType: "application/typescript",
                            languageId: 378
                        };
                    }
                }), xd = te({
                    "node_modules/linguist-languages/data/TSX.json" (e, r) {
                        r.exports = {
                            name: "TSX",
                            type: "programming",
                            color: "#3178c6",
                            group: "TypeScript",
                            extensions: [
                                ".tsx"
                            ],
                            tmScope: "source.tsx",
                            aceMode: "javascript",
                            codemirrorMode: "jsx",
                            codemirrorMimeType: "text/jsx",
                            languageId: 94901924
                        };
                    }
                }), wa = te({
                    "node_modules/linguist-languages/data/JSON.json" (e, r) {
                        r.exports = {
                            name: "JSON",
                            type: "data",
                            color: "#292929",
                            tmScope: "source.json",
                            aceMode: "json",
                            codemirrorMode: "javascript",
                            codemirrorMimeType: "application/json",
                            aliases: [
                                "geojson",
                                "jsonl",
                                "topojson"
                            ],
                            extensions: [
                                ".json",
                                ".4DForm",
                                ".4DProject",
                                ".avsc",
                                ".geojson",
                                ".gltf",
                                ".har",
                                ".ice",
                                ".JSON-tmLanguage",
                                ".jsonl",
                                ".mcmeta",
                                ".tfstate",
                                ".tfstate.backup",
                                ".topojson",
                                ".webapp",
                                ".webmanifest",
                                ".yy",
                                ".yyp"
                            ],
                            filenames: [
                                ".arcconfig",
                                ".auto-changelog",
                                ".c8rc",
                                ".htmlhintrc",
                                ".imgbotconfig",
                                ".nycrc",
                                ".tern-config",
                                ".tern-project",
                                ".watchmanconfig",
                                "Pipfile.lock",
                                "composer.lock",
                                "mcmod.info"
                            ],
                            languageId: 174
                        };
                    }
                }), bd = te({
                    "node_modules/linguist-languages/data/JSON with Comments.json" (e, r) {
                        r.exports = {
                            name: "JSON with Comments",
                            type: "data",
                            color: "#292929",
                            group: "JSON",
                            tmScope: "source.js",
                            aceMode: "javascript",
                            codemirrorMode: "javascript",
                            codemirrorMimeType: "text/javascript",
                            aliases: [
                                "jsonc"
                            ],
                            extensions: [
                                ".jsonc",
                                ".code-snippets",
                                ".sublime-build",
                                ".sublime-commands",
                                ".sublime-completions",
                                ".sublime-keymap",
                                ".sublime-macro",
                                ".sublime-menu",
                                ".sublime-mousemap",
                                ".sublime-project",
                                ".sublime-settings",
                                ".sublime-theme",
                                ".sublime-workspace",
                                ".sublime_metrics",
                                ".sublime_session"
                            ],
                            filenames: [
                                ".babelrc",
                                ".devcontainer.json",
                                ".eslintrc.json",
                                ".jscsrc",
                                ".jshintrc",
                                ".jslintrc",
                                "api-extractor.json",
                                "devcontainer.json",
                                "jsconfig.json",
                                "language-configuration.json",
                                "tsconfig.json",
                                "tslint.json"
                            ],
                            languageId: 423
                        };
                    }
                }), Td = te({
                    "node_modules/linguist-languages/data/JSON5.json" (e, r) {
                        r.exports = {
                            name: "JSON5",
                            type: "data",
                            color: "#267CB9",
                            extensions: [
                                ".json5"
                            ],
                            tmScope: "source.js",
                            aceMode: "javascript",
                            codemirrorMode: "javascript",
                            codemirrorMimeType: "application/json",
                            languageId: 175
                        };
                    }
                }), Bd = te({
                    "src/language-js/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = _t(), s = Cd(), a2 = Ed(), n = Fd(), u = Ad(), i = [
                            t1(Ln(), (p)=>({
                                    since: "0.0.0",
                                    parsers: [
                                        "babel",
                                        "acorn",
                                        "espree",
                                        "meriyah",
                                        "babel-flow",
                                        "babel-ts",
                                        "flow",
                                        "typescript"
                                    ],
                                    vscodeLanguageIds: [
                                        "javascript",
                                        "mongo"
                                    ],
                                    interpreters: [
                                        ...p.interpreters,
                                        "zx"
                                    ],
                                    extensions: [
                                        ...p.extensions.filter((y)=>y !== ".jsx"),
                                        ".wxs"
                                    ]
                                })),
                            t1(Ln(), ()=>({
                                    name: "Flow",
                                    since: "0.0.0",
                                    parsers: [
                                        "flow",
                                        "babel-flow"
                                    ],
                                    vscodeLanguageIds: [
                                        "javascript"
                                    ],
                                    aliases: [],
                                    filenames: [],
                                    extensions: [
                                        ".js.flow"
                                    ]
                                })),
                            t1(Ln(), ()=>({
                                    name: "JSX",
                                    since: "0.0.0",
                                    parsers: [
                                        "babel",
                                        "babel-flow",
                                        "babel-ts",
                                        "flow",
                                        "typescript",
                                        "espree",
                                        "meriyah"
                                    ],
                                    vscodeLanguageIds: [
                                        "javascriptreact"
                                    ],
                                    aliases: void 0,
                                    filenames: void 0,
                                    extensions: [
                                        ".jsx"
                                    ],
                                    group: "JavaScript",
                                    interpreters: void 0,
                                    tmScope: "source.js.jsx",
                                    aceMode: "javascript",
                                    codemirrorMode: "jsx",
                                    codemirrorMimeType: "text/jsx",
                                    color: void 0
                                })),
                            t1(Sd(), ()=>({
                                    since: "1.4.0",
                                    parsers: [
                                        "typescript",
                                        "babel-ts"
                                    ],
                                    vscodeLanguageIds: [
                                        "typescript"
                                    ]
                                })),
                            t1(xd(), ()=>({
                                    since: "1.4.0",
                                    parsers: [
                                        "typescript",
                                        "babel-ts"
                                    ],
                                    vscodeLanguageIds: [
                                        "typescriptreact"
                                    ]
                                })),
                            t1(wa(), ()=>({
                                    name: "JSON.stringify",
                                    since: "1.13.0",
                                    parsers: [
                                        "json-stringify"
                                    ],
                                    vscodeLanguageIds: [
                                        "json"
                                    ],
                                    extensions: [
                                        ".importmap"
                                    ],
                                    filenames: [
                                        "package.json",
                                        "package-lock.json",
                                        "composer.json"
                                    ]
                                })),
                            t1(wa(), (p)=>({
                                    since: "1.5.0",
                                    parsers: [
                                        "json"
                                    ],
                                    vscodeLanguageIds: [
                                        "json"
                                    ],
                                    extensions: p.extensions.filter((y)=>y !== ".jsonl")
                                })),
                            t1(bd(), (p)=>({
                                    since: "1.5.0",
                                    parsers: [
                                        "json"
                                    ],
                                    vscodeLanguageIds: [
                                        "jsonc"
                                    ],
                                    filenames: [
                                        ...p.filenames,
                                        ".eslintrc",
                                        ".swcrc"
                                    ]
                                })),
                            t1(Td(), ()=>({
                                    since: "1.13.0",
                                    parsers: [
                                        "json5"
                                    ],
                                    vscodeLanguageIds: [
                                        "json5"
                                    ]
                                }))
                        ], l = {
                            estree: s,
                            "estree-json": a2
                        };
                        r.exports = {
                            languages: i,
                            options: n,
                            printers: l,
                            parsers: u
                        };
                    }
                }), Nd = te({
                    "src/language-css/clean.js" (e, r) {
                        "use strict";
                        ne();
                        var { isFrontMatterNode: t1 } = Ue(), s = lt(), a2 = /* @__PURE__ */ new Set([
                            "raw",
                            "raws",
                            "sourceIndex",
                            "source",
                            "before",
                            "after",
                            "trailingComma"
                        ]);
                        function n(i, l, p) {
                            if (t1(i) && i.lang === "yaml" && delete l.value, i.type === "css-comment" && p.type === "css-root" && p.nodes.length > 0 && ((p.nodes[0] === i || t1(p.nodes[0]) && p.nodes[1] === i) && (delete l.text, /^\*\s*@(?:format|prettier)\s*$/.test(i.text)) || p.type === "css-root" && s(p.nodes) === i)) return null;
                            if (i.type === "value-root" && delete l.text, (i.type === "media-query" || i.type === "media-query-list" || i.type === "media-feature-expression") && delete l.value, i.type === "css-rule" && delete l.params, i.type === "selector-combinator" && (l.value = l.value.replace(/\s+/g, " ")), i.type === "media-feature" && (l.value = l.value.replace(/ /g, "")), (i.type === "value-word" && (i.isColor && i.isHex || [
                                "initial",
                                "inherit",
                                "unset",
                                "revert"
                            ].includes(l.value.replace().toLowerCase())) || i.type === "media-feature" || i.type === "selector-root-invalid" || i.type === "selector-pseudo") && (l.value = l.value.toLowerCase()), i.type === "css-decl" && (l.prop = l.prop.toLowerCase()), (i.type === "css-atrule" || i.type === "css-import") && (l.name = l.name.toLowerCase()), i.type === "value-number" && (l.unit = l.unit.toLowerCase()), (i.type === "media-feature" || i.type === "media-keyword" || i.type === "media-type" || i.type === "media-unknown" || i.type === "media-url" || i.type === "media-value" || i.type === "selector-attribute" || i.type === "selector-string" || i.type === "selector-class" || i.type === "selector-combinator" || i.type === "value-string") && l.value && (l.value = u(l.value)), i.type === "selector-attribute" && (l.attribute = l.attribute.trim(), l.namespace && typeof l.namespace == "string" && (l.namespace = l.namespace.trim(), l.namespace.length === 0 && (l.namespace = true)), l.value && (l.value = l.value.trim().replace(/^["']|["']$/g, ""), delete l.quoted)), (i.type === "media-value" || i.type === "media-type" || i.type === "value-number" || i.type === "selector-root-invalid" || i.type === "selector-class" || i.type === "selector-combinator" || i.type === "selector-tag") && l.value && (l.value = l.value.replace(/([\d+.Ee-]+)([A-Za-z]*)/g, (y, h, g)=>{
                                let c = Number(h);
                                return Number.isNaN(c) ? y : c + g.toLowerCase();
                            })), i.type === "selector-tag") {
                                let y = i.value.toLowerCase();
                                [
                                    "from",
                                    "to"
                                ].includes(y) && (l.value = y);
                            }
                            if (i.type === "css-atrule" && i.name.toLowerCase() === "supports" && delete l.value, i.type === "selector-unknown" && delete l.value, i.type === "value-comma_group") {
                                let y = i.groups.findIndex((h)=>h.type === "value-number" && h.unit === "...");
                                y !== -1 && (l.groups[y].unit = "", l.groups.splice(y + 1, 0, {
                                    type: "value-word",
                                    value: "...",
                                    isColor: false,
                                    isHex: false
                                }));
                            }
                            if (i.type === "value-comma_group" && i.groups.some((y)=>y.type === "value-atword" && y.value.endsWith("[") || y.type === "value-word" && y.value.startsWith("]"))) return {
                                type: "value-atword",
                                value: i.groups.map((y)=>y.value).join(""),
                                group: {
                                    open: null,
                                    close: null,
                                    groups: [],
                                    type: "value-paren_group"
                                }
                            };
                        }
                        n.ignoredProperties = a2;
                        function u(i) {
                            return i.replace(/'/g, '"').replace(/\\([^\dA-Fa-f])/g, "$1");
                        }
                        r.exports = n;
                    }
                }), su = te({
                    "src/utils/front-matter/print.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { hardline: t1, markAsRoot: s } } = qe();
                        function a2(n, u) {
                            if (n.lang === "yaml") {
                                let i = n.value.trim(), l = i ? u(i, {
                                    parser: "yaml"
                                }, {
                                    stripTrailingHardline: true
                                }) : "";
                                return s([
                                    n.startDelimiter,
                                    t1,
                                    l,
                                    l ? t1 : "",
                                    n.endDelimiter
                                ]);
                            }
                        }
                        r.exports = a2;
                    }
                }), wd = te({
                    "src/language-css/embed.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { hardline: t1 } } = qe(), s = su();
                        function a2(n, u, i) {
                            let l = n.getValue();
                            if (l.type === "front-matter") {
                                let p = s(l, i);
                                return p ? [
                                    p,
                                    t1
                                ] : "";
                            }
                        }
                        r.exports = a2;
                    }
                }), _o = te({
                    "src/utils/front-matter/parse.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = new RegExp("^(?<startDelimiter>-{3}|\\+{3})(?<language>[^\\n]*)\\n(?:|(?<value>.*?)\\n)(?<endDelimiter>\\k<startDelimiter>|\\.{3})[^\\S\\n]*(?:\\n|$)", "s");
                        function s(a2) {
                            let n = a2.match(t1);
                            if (!n) return {
                                content: a2
                            };
                            let { startDelimiter: u, language: i, value: l = "", endDelimiter: p } = n.groups, y = i.trim() || "yaml";
                            if (u === "+++" && (y = "toml"), y !== "yaml" && u !== p) return {
                                content: a2
                            };
                            let [h] = n;
                            return {
                                frontMatter: {
                                    type: "front-matter",
                                    lang: y,
                                    value: l,
                                    startDelimiter: u,
                                    endDelimiter: p,
                                    raw: h.replace(/\n$/, "")
                                },
                                content: h.replace(/[^\n]/g, " ") + a2.slice(h.length)
                            };
                        }
                        r.exports = s;
                    }
                }), _d = te({
                    "src/language-css/pragma.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Co(), s = _o();
                        function a2(u) {
                            return t1.hasPragma(s(u).content);
                        }
                        function n(u) {
                            let { frontMatter: i, content: l } = s(u);
                            return (i ? i.raw + `

` : "") + t1.insertPragma(l);
                        }
                        r.exports = {
                            hasPragma: a2,
                            insertPragma: n
                        };
                    }
                }), Pd = te({
                    "src/language-css/utils/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = /* @__PURE__ */ new Set([
                            "red",
                            "green",
                            "blue",
                            "alpha",
                            "a",
                            "rgb",
                            "hue",
                            "h",
                            "saturation",
                            "s",
                            "lightness",
                            "l",
                            "whiteness",
                            "w",
                            "blackness",
                            "b",
                            "tint",
                            "shade",
                            "blend",
                            "blenda",
                            "contrast",
                            "hsl",
                            "hsla",
                            "hwb",
                            "hwba"
                        ]);
                        function s(z, U) {
                            let Z = Array.isArray(U) ? U : [
                                U
                            ], se = -1, fe;
                            for(; fe = z.getParentNode(++se);)if (Z.includes(fe.type)) return se;
                            return -1;
                        }
                        function a2(z, U) {
                            let Z = s(z, U);
                            return Z === -1 ? null : z.getParentNode(Z);
                        }
                        function n(z) {
                            var U;
                            let Z = a2(z, "css-decl");
                            return Z == null || (U = Z.prop) === null || U === void 0 ? void 0 : U.toLowerCase();
                        }
                        var u = /* @__PURE__ */ new Set([
                            "initial",
                            "inherit",
                            "unset",
                            "revert"
                        ]);
                        function i(z) {
                            return u.has(z.toLowerCase());
                        }
                        function l(z, U) {
                            let Z = a2(z, "css-atrule");
                            return (Z == null ? void 0 : Z.name) && Z.name.toLowerCase().endsWith("keyframes") && [
                                "from",
                                "to"
                            ].includes(U.toLowerCase());
                        }
                        function p(z) {
                            return z.includes("$") || z.includes("@") || z.includes("#") || z.startsWith("%") || z.startsWith("--") || z.startsWith(":--") || z.includes("(") && z.includes(")") ? z : z.toLowerCase();
                        }
                        function y(z, U) {
                            var Z;
                            let se = a2(z, "value-func");
                            return (se == null || (Z = se.value) === null || Z === void 0 ? void 0 : Z.toLowerCase()) === U;
                        }
                        function h(z) {
                            var U;
                            let Z = a2(z, "css-rule"), se = Z == null || (U = Z.raws) === null || U === void 0 ? void 0 : U.selector;
                            return se && (se.startsWith(":import") || se.startsWith(":export"));
                        }
                        function g(z, U) {
                            let Z = Array.isArray(U) ? U : [
                                U
                            ], se = a2(z, "css-atrule");
                            return se && Z.includes(se.name.toLowerCase());
                        }
                        function c(z) {
                            let U = z.getValue(), Z = a2(z, "css-atrule");
                            return (Z == null ? void 0 : Z.name) === "import" && U.groups[0].value === "url" && U.groups.length === 2;
                        }
                        function f2(z) {
                            return z.type === "value-func" && z.value.toLowerCase() === "url";
                        }
                        function F(z, U) {
                            var Z;
                            let se = (Z = z.getParentNode()) === null || Z === void 0 ? void 0 : Z.nodes;
                            return se && se.indexOf(U) === se.length - 1;
                        }
                        function _2(z) {
                            let { selector: U } = z;
                            return U ? typeof U == "string" && /^@.+:.*$/.test(U) || U.value && /^@.+:.*$/.test(U.value) : false;
                        }
                        function w(z) {
                            return z.type === "value-word" && [
                                "from",
                                "through",
                                "end"
                            ].includes(z.value);
                        }
                        function E(z) {
                            return z.type === "value-word" && [
                                "and",
                                "or",
                                "not"
                            ].includes(z.value);
                        }
                        function N(z) {
                            return z.type === "value-word" && z.value === "in";
                        }
                        function x(z) {
                            return z.type === "value-operator" && z.value === "*";
                        }
                        function I(z) {
                            return z.type === "value-operator" && z.value === "/";
                        }
                        function P(z) {
                            return z.type === "value-operator" && z.value === "+";
                        }
                        function $(z) {
                            return z.type === "value-operator" && z.value === "-";
                        }
                        function D(z) {
                            return z.type === "value-operator" && z.value === "%";
                        }
                        function T(z) {
                            return x(z) || I(z) || P(z) || $(z) || D(z);
                        }
                        function m(z) {
                            return z.type === "value-word" && [
                                "==",
                                "!="
                            ].includes(z.value);
                        }
                        function C(z) {
                            return z.type === "value-word" && [
                                "<",
                                ">",
                                "<=",
                                ">="
                            ].includes(z.value);
                        }
                        function o(z) {
                            return z.type === "css-atrule" && [
                                "if",
                                "else",
                                "for",
                                "each",
                                "while"
                            ].includes(z.name);
                        }
                        function d(z) {
                            var U;
                            return ((U = z.raws) === null || U === void 0 ? void 0 : U.params) && /^\(\s*\)$/.test(z.raws.params);
                        }
                        function v(z) {
                            return z.name.startsWith("prettier-placeholder");
                        }
                        function S(z) {
                            return z.prop.startsWith("@prettier-placeholder");
                        }
                        function b(z, U) {
                            return z.value === "$$" && z.type === "value-func" && (U == null ? void 0 : U.type) === "value-word" && !U.raws.before;
                        }
                        function B(z) {
                            var U, Z;
                            return ((U = z.value) === null || U === void 0 ? void 0 : U.type) === "value-root" && ((Z = z.value.group) === null || Z === void 0 ? void 0 : Z.type) === "value-value" && z.prop.toLowerCase() === "composes";
                        }
                        function k(z) {
                            var U, Z, se;
                            return ((U = z.value) === null || U === void 0 || (Z = U.group) === null || Z === void 0 || (se = Z.group) === null || se === void 0 ? void 0 : se.type) === "value-paren_group" && z.value.group.group.open !== null && z.value.group.group.close !== null;
                        }
                        function M(z) {
                            var U;
                            return ((U = z.raws) === null || U === void 0 ? void 0 : U.before) === "";
                        }
                        function R(z) {
                            var U, Z;
                            return z.type === "value-comma_group" && ((U = z.groups) === null || U === void 0 || (Z = U[1]) === null || Z === void 0 ? void 0 : Z.type) === "value-colon";
                        }
                        function q(z) {
                            var U;
                            return z.type === "value-paren_group" && ((U = z.groups) === null || U === void 0 ? void 0 : U[0]) && R(z.groups[0]);
                        }
                        function J(z) {
                            var U;
                            let Z = z.getValue();
                            if (Z.groups.length === 0) return false;
                            let se = z.getParentNode(1);
                            if (!q(Z) && !(se && q(se))) return false;
                            let fe = a2(z, "css-decl");
                            return !!(fe != null && (U = fe.prop) !== null && U !== void 0 && U.startsWith("$") || q(se) || se.type === "value-func");
                        }
                        function L(z) {
                            return z.type === "value-comment" && z.inline;
                        }
                        function Q(z) {
                            return z.type === "value-word" && z.value === "#";
                        }
                        function V(z) {
                            return z.type === "value-word" && z.value === "{";
                        }
                        function j(z) {
                            return z.type === "value-word" && z.value === "}";
                        }
                        function Y(z) {
                            return [
                                "value-word",
                                "value-atword"
                            ].includes(z.type);
                        }
                        function ie(z) {
                            return (z == null ? void 0 : z.type) === "value-colon";
                        }
                        function ee(z, U) {
                            if (!R(U)) return false;
                            let { groups: Z } = U, se = Z.indexOf(z);
                            return se === -1 ? false : ie(Z[se + 1]);
                        }
                        function ce(z) {
                            return z.value && [
                                "not",
                                "and",
                                "or"
                            ].includes(z.value.toLowerCase());
                        }
                        function W(z) {
                            return z.type !== "value-func" ? false : t1.has(z.value.toLowerCase());
                        }
                        function K(z) {
                            return /\/\//.test(z.split(/[\n\r]/).pop());
                        }
                        function de(z) {
                            return (z == null ? void 0 : z.type) === "value-atword" && z.value.startsWith("prettier-placeholder-");
                        }
                        function ue(z, U) {
                            var Z, se;
                            if (((Z = z.open) === null || Z === void 0 ? void 0 : Z.value) !== "(" || ((se = z.close) === null || se === void 0 ? void 0 : se.value) !== ")" || z.groups.some((fe)=>fe.type !== "value-comma_group")) return false;
                            if (U.type === "value-comma_group") {
                                let fe = U.groups.indexOf(z) - 1, ge = U.groups[fe];
                                if ((ge == null ? void 0 : ge.type) === "value-word" && ge.value === "with") return true;
                            }
                            return false;
                        }
                        function Fe(z) {
                            var U, Z;
                            return z.type === "value-paren_group" && ((U = z.open) === null || U === void 0 ? void 0 : U.value) === "(" && ((Z = z.close) === null || Z === void 0 ? void 0 : Z.value) === ")";
                        }
                        r.exports = {
                            getAncestorCounter: s,
                            getAncestorNode: a2,
                            getPropOfDeclNode: n,
                            maybeToLowerCase: p,
                            insideValueFunctionNode: y,
                            insideICSSRuleNode: h,
                            insideAtRuleNode: g,
                            insideURLFunctionInImportAtRuleNode: c,
                            isKeyframeAtRuleKeywords: l,
                            isWideKeywords: i,
                            isLastNode: F,
                            isSCSSControlDirectiveNode: o,
                            isDetachedRulesetDeclarationNode: _2,
                            isRelationalOperatorNode: C,
                            isEqualityOperatorNode: m,
                            isMultiplicationNode: x,
                            isDivisionNode: I,
                            isAdditionNode: P,
                            isSubtractionNode: $,
                            isModuloNode: D,
                            isMathOperatorNode: T,
                            isEachKeywordNode: N,
                            isForKeywordNode: w,
                            isURLFunctionNode: f2,
                            isIfElseKeywordNode: E,
                            hasComposesNode: B,
                            hasParensAroundNode: k,
                            hasEmptyRawBefore: M,
                            isDetachedRulesetCallNode: d,
                            isTemplatePlaceholderNode: v,
                            isTemplatePropNode: S,
                            isPostcssSimpleVarNode: b,
                            isKeyValuePairNode: R,
                            isKeyValuePairInParenGroupNode: q,
                            isKeyInValuePairNode: ee,
                            isSCSSMapItemNode: J,
                            isInlineValueCommentNode: L,
                            isHashNode: Q,
                            isLeftCurlyBraceNode: V,
                            isRightCurlyBraceNode: j,
                            isWordNode: Y,
                            isColonNode: ie,
                            isMediaAndSupportsKeywords: ce,
                            isColorAdjusterFuncNode: W,
                            lastLineHasInlineComment: K,
                            isAtWordPlaceholderNode: de,
                            isConfigurationNode: ue,
                            isParenGroupNode: Fe
                        };
                    }
                }), Id = te({
                    "src/utils/line-column-to-index.js" (e, r) {
                        "use strict";
                        ne(), r.exports = function(t1, s) {
                            let a2 = 0;
                            for(let n = 0; n < t1.line - 1; ++n)a2 = s.indexOf(`
`, a2) + 1;
                            return a2 + t1.column;
                        };
                    }
                }), kd = te({
                    "src/language-css/loc.js" (e, r) {
                        "use strict";
                        ne();
                        var { skipEverythingButNewLine: t1 } = Pr(), s = lt(), a2 = Id();
                        function n(c, f2) {
                            return typeof c.sourceIndex == "number" ? c.sourceIndex : c.source ? a2(c.source.start, f2) - 1 : null;
                        }
                        function u(c, f2) {
                            if (c.type === "css-comment" && c.inline) return t1(f2, c.source.startOffset);
                            let F = c.nodes && s(c.nodes);
                            return F && c.source && !c.source.end && (c = F), c.source && c.source.end ? a2(c.source.end, f2) : null;
                        }
                        function i(c, f2) {
                            c.source && (c.source.startOffset = n(c, f2), c.source.endOffset = u(c, f2));
                            for(let F in c){
                                let _2 = c[F];
                                F === "source" || !_2 || typeof _2 != "object" || (_2.type === "value-root" || _2.type === "value-unknown" ? l(_2, p(c), _2.text || _2.value) : i(_2, f2));
                            }
                        }
                        function l(c, f2, F) {
                            c.source && (c.source.startOffset = n(c, F) + f2, c.source.endOffset = u(c, F) + f2);
                            for(let _2 in c){
                                let w = c[_2];
                                _2 === "source" || !w || typeof w != "object" || l(w, f2, F);
                            }
                        }
                        function p(c) {
                            let f2 = c.source.startOffset;
                            return typeof c.prop == "string" && (f2 += c.prop.length), c.type === "css-atrule" && typeof c.name == "string" && (f2 += 1 + c.name.length + c.raws.afterName.match(/^\s*:?\s*/)[0].length), c.type !== "css-atrule" && c.raws && typeof c.raws.between == "string" && (f2 += c.raws.between.length), f2;
                        }
                        function y(c) {
                            let f2 = "initial", F = "initial", _2, w = false, E = [];
                            for(let N = 0; N < c.length; N++){
                                let x = c[N];
                                switch(f2){
                                    case "initial":
                                        if (x === "'") {
                                            f2 = "single-quotes";
                                            continue;
                                        }
                                        if (x === '"') {
                                            f2 = "double-quotes";
                                            continue;
                                        }
                                        if ((x === "u" || x === "U") && c.slice(N, N + 4).toLowerCase() === "url(") {
                                            f2 = "url", N += 3;
                                            continue;
                                        }
                                        if (x === "*" && c[N - 1] === "/") {
                                            f2 = "comment-block";
                                            continue;
                                        }
                                        if (x === "/" && c[N - 1] === "/") {
                                            f2 = "comment-inline", _2 = N - 1;
                                            continue;
                                        }
                                        continue;
                                    case "single-quotes":
                                        if (x === "'" && c[N - 1] !== "\\" && (f2 = F, F = "initial"), x === `
` || x === "\r") return c;
                                        continue;
                                    case "double-quotes":
                                        if (x === '"' && c[N - 1] !== "\\" && (f2 = F, F = "initial"), x === `
` || x === "\r") return c;
                                        continue;
                                    case "url":
                                        if (x === ")" && (f2 = "initial"), x === `
` || x === "\r") return c;
                                        if (x === "'") {
                                            f2 = "single-quotes", F = "url";
                                            continue;
                                        }
                                        if (x === '"') {
                                            f2 = "double-quotes", F = "url";
                                            continue;
                                        }
                                        continue;
                                    case "comment-block":
                                        x === "/" && c[N - 1] === "*" && (f2 = "initial");
                                        continue;
                                    case "comment-inline":
                                        (x === '"' || x === "'" || x === "*") && (w = true), (x === `
` || x === "\r") && (w && E.push([
                                            _2,
                                            N
                                        ]), f2 = "initial", w = false);
                                        continue;
                                }
                            }
                            for (let [N, x] of E)c = c.slice(0, N) + c.slice(N, x).replace(/["'*]/g, " ") + c.slice(x);
                            return c;
                        }
                        function h(c) {
                            return c.source.startOffset;
                        }
                        function g(c) {
                            return c.source.endOffset;
                        }
                        r.exports = {
                            locStart: h,
                            locEnd: g,
                            calculateLoc: i,
                            replaceQuotesInInlineComments: y
                        };
                    }
                }), Ld = te({
                    "src/language-css/utils/is-less-parser.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s) {
                            return s.parser === "css" || s.parser === "less";
                        }
                        r.exports = t1;
                    }
                }), Od = te({
                    "src/language-css/utils/is-scss.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s, a2) {
                            return s === "less" || s === "scss" ? s === "scss" : /(?:\w\s*:\s*[^:}]+|#){|@import[^\n]+(?:url|,)/.test(a2);
                        }
                        r.exports = t1;
                    }
                }), jd = te({
                    "src/language-css/utils/css-units.evaluate.js" (e, r) {
                        r.exports = {
                            em: "em",
                            rem: "rem",
                            ex: "ex",
                            rex: "rex",
                            cap: "cap",
                            rcap: "rcap",
                            ch: "ch",
                            rch: "rch",
                            ic: "ic",
                            ric: "ric",
                            lh: "lh",
                            rlh: "rlh",
                            vw: "vw",
                            svw: "svw",
                            lvw: "lvw",
                            dvw: "dvw",
                            vh: "vh",
                            svh: "svh",
                            lvh: "lvh",
                            dvh: "dvh",
                            vi: "vi",
                            svi: "svi",
                            lvi: "lvi",
                            dvi: "dvi",
                            vb: "vb",
                            svb: "svb",
                            lvb: "lvb",
                            dvb: "dvb",
                            vmin: "vmin",
                            svmin: "svmin",
                            lvmin: "lvmin",
                            dvmin: "dvmin",
                            vmax: "vmax",
                            svmax: "svmax",
                            lvmax: "lvmax",
                            dvmax: "dvmax",
                            cm: "cm",
                            mm: "mm",
                            q: "Q",
                            in: "in",
                            pt: "pt",
                            pc: "pc",
                            px: "px",
                            deg: "deg",
                            grad: "grad",
                            rad: "rad",
                            turn: "turn",
                            s: "s",
                            ms: "ms",
                            hz: "Hz",
                            khz: "kHz",
                            dpi: "dpi",
                            dpcm: "dpcm",
                            dppx: "dppx",
                            x: "x"
                        };
                    }
                }), qd = te({
                    "src/language-css/utils/print-unit.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = jd();
                        function s(a2) {
                            let n = a2.toLowerCase();
                            return Object.prototype.hasOwnProperty.call(t1, n) ? t1[n] : a2;
                        }
                        r.exports = s;
                    }
                }), Md = te({
                    "src/language-css/printer-postcss.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = lt(), { printNumber: s, printString: a2, hasNewline: n, isFrontMatterNode: u, isNextLineEmpty: i, isNonEmptyArray: l } = Ue(), { builders: { join: p, line: y, hardline: h, softline: g, group: c, fill: f2, indent: F, dedent: _2, ifBreak: w, breakParent: E }, utils: { removeLines: N, getDocParts: x } } = qe(), I = Nd(), P = wd(), { insertPragma: $ } = _d(), { getAncestorNode: D, getPropOfDeclNode: T, maybeToLowerCase: m, insideValueFunctionNode: C, insideICSSRuleNode: o, insideAtRuleNode: d, insideURLFunctionInImportAtRuleNode: v, isKeyframeAtRuleKeywords: S, isWideKeywords: b, isLastNode: B, isSCSSControlDirectiveNode: k, isDetachedRulesetDeclarationNode: M, isRelationalOperatorNode: R, isEqualityOperatorNode: q, isMultiplicationNode: J, isDivisionNode: L, isAdditionNode: Q, isSubtractionNode: V, isMathOperatorNode: j, isEachKeywordNode: Y, isForKeywordNode: ie, isURLFunctionNode: ee, isIfElseKeywordNode: ce, hasComposesNode: W, hasParensAroundNode: K, hasEmptyRawBefore: de, isKeyValuePairNode: ue, isKeyInValuePairNode: Fe, isDetachedRulesetCallNode: z, isTemplatePlaceholderNode: U, isTemplatePropNode: Z, isPostcssSimpleVarNode: se, isSCSSMapItemNode: fe, isInlineValueCommentNode: ge, isHashNode: he, isLeftCurlyBraceNode: we, isRightCurlyBraceNode: ke, isWordNode: Re, isColonNode: Ne, isMediaAndSupportsKeywords: Pe, isColorAdjusterFuncNode: oe, lastLineHasInlineComment: H, isAtWordPlaceholderNode: pe, isConfigurationNode: X, isParenGroupNode: le } = Pd(), { locStart: Ae, locEnd: Ee } = kd(), De = Ld(), A2 = Od(), G = qd();
                        function re(Te) {
                            return Te.trailingComma === "es5" || Te.trailingComma === "all";
                        }
                        function ye(Te, je, Me) {
                            let ae = Te.getValue();
                            if (!ae) return "";
                            if (typeof ae == "string") return ae;
                            switch(ae.type){
                                case "front-matter":
                                    return [
                                        ae.raw,
                                        h
                                    ];
                                case "css-root":
                                    {
                                        let Ve = Ce(Te, je, Me), We = ae.raws.after.trim();
                                        return We.startsWith(";") && (We = We.slice(1).trim()), [
                                            Ve,
                                            We ? ` ${We}` : "",
                                            x(Ve).length > 0 ? h : ""
                                        ];
                                    }
                                case "css-comment":
                                    {
                                        let Ve = ae.inline || ae.raws.inline, We = je.originalText.slice(Ae(ae), Ee(ae));
                                        return Ve ? We.trimEnd() : We;
                                    }
                                case "css-rule":
                                    return [
                                        Me("selector"),
                                        ae.important ? " !important" : "",
                                        ae.nodes ? [
                                            ae.selector && ae.selector.type === "selector-unknown" && H(ae.selector.value) ? y : " ",
                                            "{",
                                            ae.nodes.length > 0 ? F([
                                                h,
                                                Ce(Te, je, Me)
                                            ]) : "",
                                            h,
                                            "}",
                                            M(ae) ? ";" : ""
                                        ] : ";"
                                    ];
                                case "css-decl":
                                    {
                                        let Ve = Te.getParentNode(), { between: We } = ae.raws, Xe = We.trim(), st = Xe === ":", O = W(ae) ? N(Me("value")) : Me("value");
                                        return !st && H(Xe) && (O = F([
                                            h,
                                            _2(O)
                                        ])), [
                                            ae.raws.before.replace(/[\s;]/g, ""),
                                            Ve.type === "css-atrule" && Ve.variable || o(Te) ? ae.prop : m(ae.prop),
                                            Xe.startsWith("//") ? " " : "",
                                            Xe,
                                            ae.extend ? "" : " ",
                                            De(je) && ae.extend && ae.selector ? [
                                                "extend(",
                                                Me("selector"),
                                                ")"
                                            ] : "",
                                            O,
                                            ae.raws.important ? ae.raws.important.replace(/\s*!\s*important/i, " !important") : ae.important ? " !important" : "",
                                            ae.raws.scssDefault ? ae.raws.scssDefault.replace(/\s*!default/i, " !default") : ae.scssDefault ? " !default" : "",
                                            ae.raws.scssGlobal ? ae.raws.scssGlobal.replace(/\s*!global/i, " !global") : ae.scssGlobal ? " !global" : "",
                                            ae.nodes ? [
                                                " {",
                                                F([
                                                    g,
                                                    Ce(Te, je, Me)
                                                ]),
                                                g,
                                                "}"
                                            ] : Z(ae) && !Ve.raws.semicolon && je.originalText[Ee(ae) - 1] !== ";" ? "" : je.__isHTMLStyleAttribute && B(Te, ae) ? w(";") : ";"
                                        ];
                                    }
                                case "css-atrule":
                                    {
                                        let Ve = Te.getParentNode(), We = U(ae) && !Ve.raws.semicolon && je.originalText[Ee(ae) - 1] !== ";";
                                        if (De(je)) {
                                            if (ae.mixin) return [
                                                Me("selector"),
                                                ae.important ? " !important" : "",
                                                We ? "" : ";"
                                            ];
                                            if (ae.function) return [
                                                ae.name,
                                                Me("params"),
                                                We ? "" : ";"
                                            ];
                                            if (ae.variable) return [
                                                "@",
                                                ae.name,
                                                ": ",
                                                ae.value ? Me("value") : "",
                                                ae.raws.between.trim() ? ae.raws.between.trim() + " " : "",
                                                ae.nodes ? [
                                                    "{",
                                                    F([
                                                        ae.nodes.length > 0 ? g : "",
                                                        Ce(Te, je, Me)
                                                    ]),
                                                    g,
                                                    "}"
                                                ] : "",
                                                We ? "" : ";"
                                            ];
                                        }
                                        return [
                                            "@",
                                            z(ae) || ae.name.endsWith(":") ? ae.name : m(ae.name),
                                            ae.params ? [
                                                z(ae) ? "" : U(ae) ? ae.raws.afterName === "" ? "" : ae.name.endsWith(":") ? " " : /^\s*\n\s*\n/.test(ae.raws.afterName) ? [
                                                    h,
                                                    h
                                                ] : /^\s*\n/.test(ae.raws.afterName) ? h : " " : " ",
                                                Me("params")
                                            ] : "",
                                            ae.selector ? F([
                                                " ",
                                                Me("selector")
                                            ]) : "",
                                            ae.value ? c([
                                                " ",
                                                Me("value"),
                                                k(ae) ? K(ae) ? " " : y : ""
                                            ]) : ae.name === "else" ? " " : "",
                                            ae.nodes ? [
                                                k(ae) ? "" : ae.selector && !ae.selector.nodes && typeof ae.selector.value == "string" && H(ae.selector.value) || !ae.selector && typeof ae.params == "string" && H(ae.params) ? y : " ",
                                                "{",
                                                F([
                                                    ae.nodes.length > 0 ? g : "",
                                                    Ce(Te, je, Me)
                                                ]),
                                                g,
                                                "}"
                                            ] : We ? "" : ";"
                                        ];
                                    }
                                case "media-query-list":
                                    {
                                        let Ve = [];
                                        return Te.each((We)=>{
                                            let Xe = We.getValue();
                                            Xe.type === "media-query" && Xe.value === "" || Ve.push(Me());
                                        }, "nodes"), c(F(p(y, Ve)));
                                    }
                                case "media-query":
                                    return [
                                        p(" ", Te.map(Me, "nodes")),
                                        B(Te, ae) ? "" : ","
                                    ];
                                case "media-type":
                                    return Oe(Se(ae.value, je));
                                case "media-feature-expression":
                                    return ae.nodes ? [
                                        "(",
                                        ...Te.map(Me, "nodes"),
                                        ")"
                                    ] : ae.value;
                                case "media-feature":
                                    return m(Se(ae.value.replace(/ +/g, " "), je));
                                case "media-colon":
                                    return [
                                        ae.value,
                                        " "
                                    ];
                                case "media-value":
                                    return Oe(Se(ae.value, je));
                                case "media-keyword":
                                    return Se(ae.value, je);
                                case "media-url":
                                    return Se(ae.value.replace(/^url\(\s+/gi, "url(").replace(/\s+\)$/g, ")"), je);
                                case "media-unknown":
                                    return ae.value;
                                case "selector-root":
                                    return c([
                                        d(Te, "custom-selector") ? [
                                            D(Te, "css-atrule").customSelector,
                                            y
                                        ] : "",
                                        p([
                                            ",",
                                            d(Te, [
                                                "extend",
                                                "custom-selector",
                                                "nest"
                                            ]) ? y : h
                                        ], Te.map(Me, "nodes"))
                                    ]);
                                case "selector-selector":
                                    return c(F(Te.map(Me, "nodes")));
                                case "selector-comment":
                                    return ae.value;
                                case "selector-string":
                                    return Se(ae.value, je);
                                case "selector-tag":
                                    {
                                        let Ve = Te.getParentNode(), We = Ve && Ve.nodes.indexOf(ae), Xe = We && Ve.nodes[We - 1];
                                        return [
                                            ae.namespace ? [
                                                ae.namespace === true ? "" : ae.namespace.trim(),
                                                "|"
                                            ] : "",
                                            Xe.type === "selector-nesting" ? ae.value : Oe(S(Te, ae.value) ? ae.value.toLowerCase() : ae.value)
                                        ];
                                    }
                                case "selector-id":
                                    return [
                                        "#",
                                        ae.value
                                    ];
                                case "selector-class":
                                    return [
                                        ".",
                                        Oe(Se(ae.value, je))
                                    ];
                                case "selector-attribute":
                                    {
                                        var nt;
                                        return [
                                            "[",
                                            ae.namespace ? [
                                                ae.namespace === true ? "" : ae.namespace.trim(),
                                                "|"
                                            ] : "",
                                            ae.attribute.trim(),
                                            (nt = ae.operator) !== null && nt !== void 0 ? nt : "",
                                            ae.value ? Ie(Se(ae.value.trim(), je), je) : "",
                                            ae.insensitive ? " i" : "",
                                            "]"
                                        ];
                                    }
                                case "selector-combinator":
                                    {
                                        if (ae.value === "+" || ae.value === ">" || ae.value === "~" || ae.value === ">>>") {
                                            let Xe = Te.getParentNode();
                                            return [
                                                Xe.type === "selector-selector" && Xe.nodes[0] === ae ? "" : y,
                                                ae.value,
                                                B(Te, ae) ? "" : " "
                                            ];
                                        }
                                        let Ve = ae.value.trim().startsWith("(") ? y : "", We = Oe(Se(ae.value.trim(), je)) || y;
                                        return [
                                            Ve,
                                            We
                                        ];
                                    }
                                case "selector-universal":
                                    return [
                                        ae.namespace ? [
                                            ae.namespace === true ? "" : ae.namespace.trim(),
                                            "|"
                                        ] : "",
                                        ae.value
                                    ];
                                case "selector-pseudo":
                                    return [
                                        m(ae.value),
                                        l(ae.nodes) ? c([
                                            "(",
                                            F([
                                                g,
                                                p([
                                                    ",",
                                                    y
                                                ], Te.map(Me, "nodes"))
                                            ]),
                                            g,
                                            ")"
                                        ]) : ""
                                    ];
                                case "selector-nesting":
                                    return ae.value;
                                case "selector-unknown":
                                    {
                                        let Ve = D(Te, "css-rule");
                                        if (Ve && Ve.isSCSSNesterProperty) return Oe(Se(m(ae.value), je));
                                        let We = Te.getParentNode();
                                        if (We.raws && We.raws.selector) {
                                            let st = Ae(We), O = st + We.raws.selector.length;
                                            return je.originalText.slice(st, O).trim();
                                        }
                                        let Xe = Te.getParentNode(1);
                                        if (We.type === "value-paren_group" && Xe && Xe.type === "value-func" && Xe.value === "selector") {
                                            let st = Ee(We.open) + 1, O = Ae(We.close), me = je.originalText.slice(st, O).trim();
                                            return H(me) ? [
                                                E,
                                                me
                                            ] : me;
                                        }
                                        return ae.value;
                                    }
                                case "value-value":
                                case "value-root":
                                    return Me("group");
                                case "value-comment":
                                    return je.originalText.slice(Ae(ae), Ee(ae));
                                case "value-comma_group":
                                    {
                                        let Ve = Te.getParentNode(), We = Te.getParentNode(1), Xe = T(Te), st = Xe && Ve.type === "value-value" && (Xe === "grid" || Xe.startsWith("grid-template")), O = D(Te, "css-atrule"), me = O && k(O), _e = ae.groups.some((at)=>ge(at)), He = Te.map(Me, "groups"), Ge = [], it = C(Te, "url"), Qe = false, rt = false;
                                        for(let at = 0; at < ae.groups.length; ++at){
                                            var tt;
                                            Ge.push(He[at]);
                                            let Ze = ae.groups[at - 1], Le = ae.groups[at], $e = ae.groups[at + 1], sr = ae.groups[at + 2];
                                            if (it) {
                                                ($e && Q($e) || Q(Le)) && Ge.push(" ");
                                                continue;
                                            }
                                            if (d(Te, "forward") && Le.type === "value-word" && Le.value && Ze !== void 0 && Ze.type === "value-word" && Ze.value === "as" && $e.type === "value-operator" && $e.value === "*" || !$e || Le.type === "value-word" && Le.value.endsWith("-") && pe($e)) continue;
                                            if (Le.type === "value-string" && Le.quoted) {
                                                let $r = Le.value.lastIndexOf("#{"), Vr = Le.value.lastIndexOf("}");
                                                $r !== -1 && Vr !== -1 ? Qe = $r > Vr : $r !== -1 ? Qe = true : Vr !== -1 && (Qe = false);
                                            }
                                            if (Qe || Ne(Le) || Ne($e) || Le.type === "value-atword" && (Le.value === "" || Le.value.endsWith("[")) || $e.type === "value-word" && $e.value.startsWith("]") || Le.value === "~" || Le.value && Le.value.includes("\\") && $e && $e.type !== "value-comment" || Ze && Ze.value && Ze.value.indexOf("\\") === Ze.value.length - 1 && Le.type === "value-operator" && Le.value === "/" || Le.value === "\\" || se(Le, $e) || he(Le) || we(Le) || ke($e) || we($e) && de($e) || ke(Le) && de($e) || Le.value === "--" && he($e)) continue;
                                            let Rr = j(Le), ou = j($e);
                                            if ((Rr && he($e) || ou && ke(Le)) && de($e) || !Ze && L(Le) || C(Te, "calc") && (Q(Le) || Q($e) || V(Le) || V($e)) && de($e)) continue;
                                            let qo = (Q(Le) || V(Le)) && at === 0 && ($e.type === "value-number" || $e.isHex) && We && oe(We) && !de($e), lu = sr && sr.type === "value-func" || sr && Re(sr) || Le.type === "value-func" || Re(Le), cu = $e.type === "value-func" || Re($e) || Ze && Ze.type === "value-func" || Ze && Re(Ze);
                                            if (!(!(J($e) || J(Le)) && !C(Te, "calc") && !qo && (L($e) && !lu || L(Le) && !cu || Q($e) && !lu || Q(Le) && !cu || V($e) || V(Le)) && (de($e) || Rr && (!Ze || Ze && j(Ze)))) && !((je.parser === "scss" || je.parser === "less") && Rr && Le.value === "-" && le($e) && Ee(Le) === Ae($e.open) && $e.open.value === "(")) {
                                                if (ge(Le)) {
                                                    if (Ve.type === "value-paren_group") {
                                                        Ge.push(_2(h));
                                                        continue;
                                                    }
                                                    Ge.push(h);
                                                    continue;
                                                }
                                                if (me && (q($e) || R($e) || ce($e) || Y(Le) || ie(Le))) {
                                                    Ge.push(" ");
                                                    continue;
                                                }
                                                if (O && O.name.toLowerCase() === "namespace") {
                                                    Ge.push(" ");
                                                    continue;
                                                }
                                                if (st) {
                                                    Le.source && $e.source && Le.source.start.line !== $e.source.start.line ? (Ge.push(h), rt = true) : Ge.push(" ");
                                                    continue;
                                                }
                                                if (ou) {
                                                    Ge.push(" ");
                                                    continue;
                                                }
                                                if (!($e && $e.value === "...") && !(pe(Le) && pe($e) && Ee(Le) === Ae($e))) {
                                                    if (pe(Le) && le($e) && Ee(Le) === Ae($e.open)) {
                                                        Ge.push(g);
                                                        continue;
                                                    }
                                                    if (Le.value === "with" && le($e)) {
                                                        Ge.push(" ");
                                                        continue;
                                                    }
                                                    (tt = Le.value) !== null && tt !== void 0 && tt.endsWith("#") && $e.value === "{" && le($e.group) || Ge.push(y);
                                                }
                                            }
                                        }
                                        return _e && Ge.push(E), rt && Ge.unshift(h), me ? c(F(Ge)) : v(Te) ? c(f2(Ge)) : c(F(f2(Ge)));
                                    }
                                case "value-paren_group":
                                    {
                                        let Ve = Te.getParentNode();
                                        if (Ve && ee(Ve) && (ae.groups.length === 1 || ae.groups.length > 0 && ae.groups[0].type === "value-comma_group" && ae.groups[0].groups.length > 0 && ae.groups[0].groups[0].type === "value-word" && ae.groups[0].groups[0].value.startsWith("data:"))) return [
                                            ae.open ? Me("open") : "",
                                            p(",", Te.map(Me, "groups")),
                                            ae.close ? Me("close") : ""
                                        ];
                                        if (!ae.open) {
                                            let it = Te.map(Me, "groups"), Qe = [];
                                            for(let rt = 0; rt < it.length; rt++)rt !== 0 && Qe.push([
                                                ",",
                                                y
                                            ]), Qe.push(it[rt]);
                                            return c(F(f2(Qe)));
                                        }
                                        let We = fe(Te), Xe = t1(ae.groups), st = Xe && Xe.type === "value-comment", O = Fe(ae, Ve), me = X(ae, Ve), _e = me || We && !O, He = me || O, Ge = c([
                                            ae.open ? Me("open") : "",
                                            F([
                                                g,
                                                p([
                                                    y
                                                ], Te.map((it, Qe)=>{
                                                    let rt = it.getValue(), at = Qe === ae.groups.length - 1, Ze = [
                                                        Me(),
                                                        at ? "" : ","
                                                    ];
                                                    if (ue(rt) && rt.type === "value-comma_group" && rt.groups && rt.groups[0].type !== "value-paren_group" && rt.groups[2] && rt.groups[2].type === "value-paren_group") {
                                                        let Le = x(Ze[0].contents.contents);
                                                        Le[1] = c(Le[1]), Ze = [
                                                            c(_2(Ze))
                                                        ];
                                                    }
                                                    if (!at && rt.type === "value-comma_group" && l(rt.groups)) {
                                                        let Le = t1(rt.groups);
                                                        !Le.source && Le.close && (Le = Le.close), Le.source && i(je.originalText, Le, Ee) && Ze.push(h);
                                                    }
                                                    return Ze;
                                                }, "groups"))
                                            ]),
                                            w(!st && A2(je.parser, je.originalText) && We && re(je) ? "," : ""),
                                            g,
                                            ae.close ? Me("close") : ""
                                        ], {
                                            shouldBreak: _e
                                        });
                                        return He ? _2(Ge) : Ge;
                                    }
                                case "value-func":
                                    return [
                                        ae.value,
                                        d(Te, "supports") && Pe(ae) ? " " : "",
                                        Me("group")
                                    ];
                                case "value-paren":
                                    return ae.value;
                                case "value-number":
                                    return [
                                        Je(ae.value),
                                        G(ae.unit)
                                    ];
                                case "value-operator":
                                    return ae.value;
                                case "value-word":
                                    return ae.isColor && ae.isHex || b(ae.value) ? ae.value.toLowerCase() : ae.value;
                                case "value-colon":
                                    {
                                        let Ve = Te.getParentNode(), We = Ve && Ve.groups.indexOf(ae), Xe = We && Ve.groups[We - 1];
                                        return [
                                            ae.value,
                                            Xe && typeof Xe.value == "string" && t1(Xe.value) === "\\" || C(Te, "url") ? "" : y
                                        ];
                                    }
                                case "value-comma":
                                    return [
                                        ae.value,
                                        " "
                                    ];
                                case "value-string":
                                    return a2(ae.raws.quote + ae.value + ae.raws.quote, je);
                                case "value-atword":
                                    return [
                                        "@",
                                        ae.value
                                    ];
                                case "value-unicode-range":
                                    return ae.value;
                                case "value-unknown":
                                    return ae.value;
                                default:
                                    throw new Error(`Unknown postcss type ${JSON.stringify(ae.type)}`);
                            }
                        }
                        function Ce(Te, je, Me) {
                            let ae = [];
                            return Te.each((nt, tt, Ve)=>{
                                let We = Ve[tt - 1];
                                if (We && We.type === "css-comment" && We.text.trim() === "prettier-ignore") {
                                    let Xe = nt.getValue();
                                    ae.push(je.originalText.slice(Ae(Xe), Ee(Xe)));
                                } else ae.push(Me());
                                tt !== Ve.length - 1 && (Ve[tt + 1].type === "css-comment" && !n(je.originalText, Ae(Ve[tt + 1]), {
                                    backwards: true
                                }) && !u(Ve[tt]) || Ve[tt + 1].type === "css-atrule" && Ve[tt + 1].name === "else" && Ve[tt].type !== "css-comment" ? ae.push(" ") : (ae.push(je.__isHTMLStyleAttribute ? y : h), i(je.originalText, nt.getValue(), Ee) && !u(Ve[tt]) && ae.push(h)));
                            }, "nodes"), ae;
                        }
                        var Be = RegExp("([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*\\1", "gs"), ve = /(?:\d*\.\d+|\d+\.?)(?:[Ee][+-]?\d+)?/g, ze = /[A-Za-z]+/g, be = /[$@]?[A-Z_a-z\u0080-\uFFFF][\w\u0080-\uFFFF-]*/g, Ye = new RegExp(Be.source + `|(${be.source})?(${ve.source})(${ze.source})?`, "g");
                        function Se(Te, je) {
                            return Te.replace(Be, (Me)=>a2(Me, je));
                        }
                        function Ie(Te, je) {
                            let Me = je.singleQuote ? "'" : '"';
                            return Te.includes('"') || Te.includes("'") ? Te : Me + Te + Me;
                        }
                        function Oe(Te) {
                            return Te.replace(Ye, (je, Me, ae, nt, tt)=>!ae && nt ? Je(nt) + m(tt || "") : je);
                        }
                        function Je(Te) {
                            return s(Te).replace(/\.0(?=$|e)/, "");
                        }
                        r.exports = {
                            print: ye,
                            embed: P,
                            insertPragma: $,
                            massageAstNode: I
                        };
                    }
                }), Rd = te({
                    "src/language-css/options.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Mt();
                        r.exports = {
                            singleQuote: t1.singleQuote
                        };
                    }
                }), $d = te({
                    "src/language-css/parsers.js" () {
                        ne();
                    }
                }), Vd = te({
                    "node_modules/linguist-languages/data/CSS.json" (e, r) {
                        r.exports = {
                            name: "CSS",
                            type: "markup",
                            tmScope: "source.css",
                            aceMode: "css",
                            codemirrorMode: "css",
                            codemirrorMimeType: "text/css",
                            color: "#563d7c",
                            extensions: [
                                ".css"
                            ],
                            languageId: 50
                        };
                    }
                }), Wd = te({
                    "node_modules/linguist-languages/data/PostCSS.json" (e, r) {
                        r.exports = {
                            name: "PostCSS",
                            type: "markup",
                            color: "#dc3a0c",
                            tmScope: "source.postcss",
                            group: "CSS",
                            extensions: [
                                ".pcss",
                                ".postcss"
                            ],
                            aceMode: "text",
                            languageId: 262764437
                        };
                    }
                }), Hd = te({
                    "node_modules/linguist-languages/data/Less.json" (e, r) {
                        r.exports = {
                            name: "Less",
                            type: "markup",
                            color: "#1d365d",
                            aliases: [
                                "less-css"
                            ],
                            extensions: [
                                ".less"
                            ],
                            tmScope: "source.css.less",
                            aceMode: "less",
                            codemirrorMode: "css",
                            codemirrorMimeType: "text/css",
                            languageId: 198
                        };
                    }
                }), Gd = te({
                    "node_modules/linguist-languages/data/SCSS.json" (e, r) {
                        r.exports = {
                            name: "SCSS",
                            type: "markup",
                            color: "#c6538c",
                            tmScope: "source.css.scss",
                            aceMode: "scss",
                            codemirrorMode: "css",
                            codemirrorMimeType: "text/x-scss",
                            extensions: [
                                ".scss"
                            ],
                            languageId: 329
                        };
                    }
                }), Ud = te({
                    "src/language-css/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = _t(), s = Md(), a2 = Rd(), n = $d(), u = [
                            t1(Vd(), (l)=>({
                                    since: "1.4.0",
                                    parsers: [
                                        "css"
                                    ],
                                    vscodeLanguageIds: [
                                        "css"
                                    ],
                                    extensions: [
                                        ...l.extensions,
                                        ".wxss"
                                    ]
                                })),
                            t1(Wd(), ()=>({
                                    since: "1.4.0",
                                    parsers: [
                                        "css"
                                    ],
                                    vscodeLanguageIds: [
                                        "postcss"
                                    ]
                                })),
                            t1(Hd(), ()=>({
                                    since: "1.4.0",
                                    parsers: [
                                        "less"
                                    ],
                                    vscodeLanguageIds: [
                                        "less"
                                    ]
                                })),
                            t1(Gd(), ()=>({
                                    since: "1.4.0",
                                    parsers: [
                                        "scss"
                                    ],
                                    vscodeLanguageIds: [
                                        "scss"
                                    ]
                                }))
                        ], i = {
                            postcss: s
                        };
                        r.exports = {
                            languages: u,
                            options: a2,
                            printers: i,
                            parsers: n
                        };
                    }
                }), Jd = te({
                    "src/language-handlebars/loc.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(a2) {
                            return a2.loc.start.offset;
                        }
                        function s(a2) {
                            return a2.loc.end.offset;
                        }
                        r.exports = {
                            locStart: t1,
                            locEnd: s
                        };
                    }
                }), zd = te({
                    "src/language-handlebars/clean.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s, a2) {
                            if (s.type === "TextNode") {
                                let n = s.chars.trim();
                                if (!n) return null;
                                a2.chars = n.replace(/[\t\n\f\r ]+/g, " ");
                            }
                            s.type === "AttrNode" && s.name.toLowerCase() === "class" && delete a2.value;
                        }
                        t1.ignoredProperties = /* @__PURE__ */ new Set([
                            "loc",
                            "selfClosing"
                        ]), r.exports = t1;
                    }
                }), Xd = te({
                    "src/language-handlebars/html-void-elements.evaluate.js" (e, r) {
                        r.exports = [
                            "area",
                            "base",
                            "br",
                            "col",
                            "command",
                            "embed",
                            "hr",
                            "img",
                            "input",
                            "keygen",
                            "link",
                            "meta",
                            "param",
                            "source",
                            "track",
                            "wbr"
                        ];
                    }
                }), Kd = te({
                    "src/language-handlebars/utils.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = lt(), s = Xd();
                        function a2(x) {
                            let I = x.getValue(), P = x.getParentNode(0);
                            return !!(g(x, [
                                "ElementNode"
                            ]) && t1(P.children) === I || g(x, [
                                "Block"
                            ]) && t1(P.body) === I);
                        }
                        function n(x) {
                            return x.toUpperCase() === x;
                        }
                        function u(x) {
                            return h(x, [
                                "ElementNode"
                            ]) && typeof x.tag == "string" && !x.tag.startsWith(":") && (n(x.tag[0]) || x.tag.includes("."));
                        }
                        var i = new Set(s);
                        function l(x) {
                            return i.has(x.toLowerCase()) && !n(x[0]);
                        }
                        function p(x) {
                            return x.selfClosing === true || l(x.tag) || u(x) && x.children.every((I)=>y(I));
                        }
                        function y(x) {
                            return h(x, [
                                "TextNode"
                            ]) && !/\S/.test(x.chars);
                        }
                        function h(x, I) {
                            return x && I.includes(x.type);
                        }
                        function g(x, I) {
                            let P = x.getParentNode(0);
                            return h(P, I);
                        }
                        function c(x, I) {
                            let P = _2(x);
                            return h(P, I);
                        }
                        function f2(x, I) {
                            let P = w(x);
                            return h(P, I);
                        }
                        function F(x, I) {
                            var P, $, D, T;
                            let m = x.getValue(), C = (P = x.getParentNode(0)) !== null && P !== void 0 ? P : {}, o = ($ = (D = (T = C.children) !== null && T !== void 0 ? T : C.body) !== null && D !== void 0 ? D : C.parts) !== null && $ !== void 0 ? $ : [], d = o.indexOf(m);
                            return d !== -1 && o[d + I];
                        }
                        function _2(x) {
                            let I = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
                            return F(x, -I);
                        }
                        function w(x) {
                            return F(x, 1);
                        }
                        function E(x) {
                            return h(x, [
                                "MustacheCommentStatement"
                            ]) && typeof x.value == "string" && x.value.trim() === "prettier-ignore";
                        }
                        function N(x) {
                            let I = x.getValue(), P = _2(x, 2);
                            return E(I) || E(P);
                        }
                        r.exports = {
                            getNextNode: w,
                            getPreviousNode: _2,
                            hasPrettierIgnore: N,
                            isLastNodeOfSiblings: a2,
                            isNextNodeOfSomeType: f2,
                            isNodeOfSomeType: h,
                            isParentOfSomeType: g,
                            isPreviousNodeOfSomeType: c,
                            isVoid: p,
                            isWhitespaceNode: y
                        };
                    }
                }), Yd = te({
                    "src/language-handlebars/printer-glimmer.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { dedent: t1, fill: s, group: a2, hardline: n, ifBreak: u, indent: i, join: l, line: p, softline: y }, utils: { getDocParts: h, replaceTextEndOfLine: g } } = qe(), { getPreferredQuote: c, isNonEmptyArray: f2 } = Ue(), { locStart: F, locEnd: _2 } = Jd(), w = zd(), { getNextNode: E, getPreviousNode: N, hasPrettierIgnore: x, isLastNodeOfSiblings: I, isNextNodeOfSomeType: P, isNodeOfSomeType: $, isParentOfSomeType: D, isPreviousNodeOfSomeType: T, isVoid: m, isWhitespaceNode: C } = Kd(), o = 2;
                        function d(H, pe, X) {
                            let le = H.getValue();
                            if (!le) return "";
                            if (x(H)) return pe.originalText.slice(F(le), _2(le));
                            let Ae = pe.singleQuote ? "'" : '"';
                            switch(le.type){
                                case "Block":
                                case "Program":
                                case "Template":
                                    return a2(H.map(X, "body"));
                                case "ElementNode":
                                    {
                                        let Ee = a2(S(H, X)), De = pe.htmlWhitespaceSensitivity === "ignore" && P(H, [
                                            "ElementNode"
                                        ]) ? y : "";
                                        if (m(le)) return [
                                            Ee,
                                            De
                                        ];
                                        let A2 = [
                                            "</",
                                            le.tag,
                                            ">"
                                        ];
                                        return le.children.length === 0 ? [
                                            Ee,
                                            i(A2),
                                            De
                                        ] : pe.htmlWhitespaceSensitivity === "ignore" ? [
                                            Ee,
                                            i(b(H, pe, X)),
                                            n,
                                            i(A2),
                                            De
                                        ] : [
                                            Ee,
                                            i(a2(b(H, pe, X))),
                                            i(A2),
                                            De
                                        ];
                                    }
                                case "BlockStatement":
                                    {
                                        let Ee = H.getParentNode(1);
                                        return Ee && Ee.inverse && Ee.inverse.body.length === 1 && Ee.inverse.body[0] === le && Ee.inverse.body[0].path.parts[0] === Ee.path.parts[0] ? [
                                            ie(H, X, Ee.inverse.body[0].path.parts[0]),
                                            de(H, X, pe),
                                            ue(H, X, pe)
                                        ] : [
                                            j(H, X),
                                            a2([
                                                de(H, X, pe),
                                                ue(H, X, pe),
                                                ee(H, X, pe)
                                            ])
                                        ];
                                    }
                                case "ElementModifierStatement":
                                    return a2([
                                        "{{",
                                        Re(H, X),
                                        "}}"
                                    ]);
                                case "MustacheStatement":
                                    return a2([
                                        k(le),
                                        Re(H, X),
                                        M(le)
                                    ]);
                                case "SubExpression":
                                    return a2([
                                        "(",
                                        ke(H, X),
                                        y,
                                        ")"
                                    ]);
                                case "AttrNode":
                                    {
                                        let Ee = le.value.type === "TextNode";
                                        if (Ee && le.value.chars === "" && F(le.value) === _2(le.value)) return le.name;
                                        let A2 = Ee ? c(le.value.chars, Ae).quote : le.value.type === "ConcatStatement" ? c(le.value.parts.filter((re)=>re.type === "TextNode").map((re)=>re.chars).join(""), Ae).quote : "", G = X("value");
                                        return [
                                            le.name,
                                            "=",
                                            A2,
                                            le.name === "class" && A2 ? a2(i(G)) : G,
                                            A2
                                        ];
                                    }
                                case "ConcatStatement":
                                    return H.map(X, "parts");
                                case "Hash":
                                    return l(p, H.map(X, "pairs"));
                                case "HashPair":
                                    return [
                                        le.key,
                                        "=",
                                        X("value")
                                    ];
                                case "TextNode":
                                    {
                                        let Ee = le.chars.replace(/{{/g, "\\{{"), De = U(H);
                                        if (De) {
                                            if (De === "class") {
                                                let Ye = Ee.trim().split(/\s+/).join(" "), Se = false, Ie = false;
                                                return D(H, [
                                                    "ConcatStatement"
                                                ]) && (T(H, [
                                                    "MustacheStatement"
                                                ]) && /^\s/.test(Ee) && (Se = true), P(H, [
                                                    "MustacheStatement"
                                                ]) && /\s$/.test(Ee) && Ye !== "" && (Ie = true)), [
                                                    Se ? p : "",
                                                    Ye,
                                                    Ie ? p : ""
                                                ];
                                            }
                                            return g(Ee);
                                        }
                                        let G = /^[\t\n\f\r ]*$/.test(Ee), re = !N(H), ye = !E(H);
                                        if (pe.htmlWhitespaceSensitivity !== "ignore") {
                                            let Ye = /^[\t\n\f\r ]*/, Se = /[\t\n\f\r ]*$/, Ie = ye && D(H, [
                                                "Template"
                                            ]), Oe = re && D(H, [
                                                "Template"
                                            ]);
                                            if (G) {
                                                if (Oe || Ie) return "";
                                                let ae = [
                                                    p
                                                ], nt = Z(Ee);
                                                return nt && (ae = ge(nt)), I(H) && (ae = ae.map((tt)=>t1(tt))), ae;
                                            }
                                            let [Je] = Ee.match(Ye), [Te] = Ee.match(Se), je = [];
                                            if (Je) {
                                                je = [
                                                    p
                                                ];
                                                let ae = Z(Je);
                                                ae && (je = ge(ae)), Ee = Ee.replace(Ye, "");
                                            }
                                            let Me = [];
                                            if (Te) {
                                                if (!Ie) {
                                                    Me = [
                                                        p
                                                    ];
                                                    let ae = Z(Te);
                                                    ae && (Me = ge(ae)), I(H) && (Me = Me.map((nt)=>t1(nt)));
                                                }
                                                Ee = Ee.replace(Se, "");
                                            }
                                            return [
                                                ...je,
                                                s(Fe(Ee)),
                                                ...Me
                                            ];
                                        }
                                        let Ce = Z(Ee), Be = se(Ee), ve = fe(Ee);
                                        if ((re || ye) && G && D(H, [
                                            "Block",
                                            "ElementNode",
                                            "Template"
                                        ])) return "";
                                        G && Ce ? (Be = Math.min(Ce, o), ve = 0) : (P(H, [
                                            "BlockStatement",
                                            "ElementNode"
                                        ]) && (ve = Math.max(ve, 1)), T(H, [
                                            "BlockStatement",
                                            "ElementNode"
                                        ]) && (Be = Math.max(Be, 1)));
                                        let ze = "", be = "";
                                        return ve === 0 && P(H, [
                                            "MustacheStatement"
                                        ]) && (be = " "), Be === 0 && T(H, [
                                            "MustacheStatement"
                                        ]) && (ze = " "), re && (Be = 0, ze = ""), ye && (ve = 0, be = ""), Ee = Ee.replace(/^[\t\n\f\r ]+/g, ze).replace(/[\t\n\f\r ]+$/, be), [
                                            ...ge(Be),
                                            s(Fe(Ee)),
                                            ...ge(ve)
                                        ];
                                    }
                                case "MustacheCommentStatement":
                                    {
                                        let Ee = F(le), De = _2(le), A2 = pe.originalText.charAt(Ee + 2) === "~", G = pe.originalText.charAt(De - 3) === "~", re = le.value.includes("}}") ? "--" : "";
                                        return [
                                            "{{",
                                            A2 ? "~" : "",
                                            "!",
                                            re,
                                            le.value,
                                            re,
                                            G ? "~" : "",
                                            "}}"
                                        ];
                                    }
                                case "PathExpression":
                                    return le.original;
                                case "BooleanLiteral":
                                    return String(le.value);
                                case "CommentStatement":
                                    return [
                                        "<!--",
                                        le.value,
                                        "-->"
                                    ];
                                case "StringLiteral":
                                    {
                                        if (we(H)) {
                                            let Ee = pe.singleQuote ? '"' : "'";
                                            return he(le.value, Ee);
                                        }
                                        return he(le.value, Ae);
                                    }
                                case "NumberLiteral":
                                    return String(le.value);
                                case "UndefinedLiteral":
                                    return "undefined";
                                case "NullLiteral":
                                    return "null";
                                default:
                                    throw new Error("unknown glimmer type: " + JSON.stringify(le.type));
                            }
                        }
                        function v(H, pe) {
                            return F(H) - F(pe);
                        }
                        function S(H, pe) {
                            let X = H.getValue(), le = [
                                "attributes",
                                "modifiers",
                                "comments"
                            ].filter((Ee)=>f2(X[Ee])), Ae = le.flatMap((Ee)=>X[Ee]).sort(v);
                            for (let Ee of le)H.each((De)=>{
                                let A2 = Ae.indexOf(De.getValue());
                                Ae.splice(A2, 1, [
                                    p,
                                    pe()
                                ]);
                            }, Ee);
                            return f2(X.blockParams) && Ae.push(p, oe(X)), [
                                "<",
                                X.tag,
                                i(Ae),
                                B(X)
                            ];
                        }
                        function b(H, pe, X) {
                            let Ae = H.getValue().children.every((Ee)=>C(Ee));
                            return pe.htmlWhitespaceSensitivity === "ignore" && Ae ? "" : H.map((Ee, De)=>{
                                let A2 = X();
                                return De === 0 && pe.htmlWhitespaceSensitivity === "ignore" ? [
                                    y,
                                    A2
                                ] : A2;
                            }, "children");
                        }
                        function B(H) {
                            return m(H) ? u([
                                y,
                                "/>"
                            ], [
                                " />",
                                y
                            ]) : u([
                                y,
                                ">"
                            ], ">");
                        }
                        function k(H) {
                            let pe = H.escaped === false ? "{{{" : "{{", X = H.strip && H.strip.open ? "~" : "";
                            return [
                                pe,
                                X
                            ];
                        }
                        function M(H) {
                            let pe = H.escaped === false ? "}}}" : "}}";
                            return [
                                H.strip && H.strip.close ? "~" : "",
                                pe
                            ];
                        }
                        function R(H) {
                            let pe = k(H), X = H.openStrip.open ? "~" : "";
                            return [
                                pe,
                                X,
                                "#"
                            ];
                        }
                        function q(H) {
                            let pe = M(H);
                            return [
                                H.openStrip.close ? "~" : "",
                                pe
                            ];
                        }
                        function J(H) {
                            let pe = k(H), X = H.closeStrip.open ? "~" : "";
                            return [
                                pe,
                                X,
                                "/"
                            ];
                        }
                        function L(H) {
                            let pe = M(H);
                            return [
                                H.closeStrip.close ? "~" : "",
                                pe
                            ];
                        }
                        function Q(H) {
                            let pe = k(H), X = H.inverseStrip.open ? "~" : "";
                            return [
                                pe,
                                X
                            ];
                        }
                        function V(H) {
                            let pe = M(H);
                            return [
                                H.inverseStrip.close ? "~" : "",
                                pe
                            ];
                        }
                        function j(H, pe) {
                            let X = H.getValue(), le = [], Ae = Pe(H, pe);
                            return Ae && le.push(a2(Ae)), f2(X.program.blockParams) && le.push(oe(X.program)), a2([
                                R(X),
                                Ne(H, pe),
                                le.length > 0 ? i([
                                    p,
                                    l(p, le)
                                ]) : "",
                                y,
                                q(X)
                            ]);
                        }
                        function Y(H, pe) {
                            return [
                                pe.htmlWhitespaceSensitivity === "ignore" ? n : "",
                                Q(H),
                                "else",
                                V(H)
                            ];
                        }
                        function ie(H, pe, X) {
                            let le = H.getValue(), Ae = H.getParentNode(1);
                            return a2([
                                Q(Ae),
                                [
                                    "else",
                                    " ",
                                    X
                                ],
                                i([
                                    p,
                                    a2(Pe(H, pe)),
                                    ...f2(le.program.blockParams) ? [
                                        p,
                                        oe(le.program)
                                    ] : []
                                ]),
                                y,
                                V(Ae)
                            ]);
                        }
                        function ee(H, pe, X) {
                            let le = H.getValue();
                            return X.htmlWhitespaceSensitivity === "ignore" ? [
                                ce(le) ? y : n,
                                J(le),
                                pe("path"),
                                L(le)
                            ] : [
                                J(le),
                                pe("path"),
                                L(le)
                            ];
                        }
                        function ce(H) {
                            return $(H, [
                                "BlockStatement"
                            ]) && H.program.body.every((pe)=>C(pe));
                        }
                        function W(H) {
                            return K(H) && H.inverse.body.length === 1 && $(H.inverse.body[0], [
                                "BlockStatement"
                            ]) && H.inverse.body[0].path.parts[0] === H.path.parts[0];
                        }
                        function K(H) {
                            return $(H, [
                                "BlockStatement"
                            ]) && H.inverse;
                        }
                        function de(H, pe, X) {
                            let le = H.getValue();
                            if (ce(le)) return "";
                            let Ae = pe("program");
                            return X.htmlWhitespaceSensitivity === "ignore" ? i([
                                n,
                                Ae
                            ]) : i(Ae);
                        }
                        function ue(H, pe, X) {
                            let le = H.getValue(), Ae = pe("inverse"), Ee = X.htmlWhitespaceSensitivity === "ignore" ? [
                                n,
                                Ae
                            ] : Ae;
                            return W(le) ? Ee : K(le) ? [
                                Y(le, X),
                                i(Ee)
                            ] : "";
                        }
                        function Fe(H) {
                            return h(l(p, z(H)));
                        }
                        function z(H) {
                            return H.split(/[\t\n\f\r ]+/);
                        }
                        function U(H) {
                            for(let pe = 0; pe < 2; pe++){
                                let X = H.getParentNode(pe);
                                if (X && X.type === "AttrNode") return X.name.toLowerCase();
                            }
                        }
                        function Z(H) {
                            return H = typeof H == "string" ? H : "", H.split(`
`).length - 1;
                        }
                        function se(H) {
                            H = typeof H == "string" ? H : "";
                            let pe = (H.match(/^([^\S\n\r]*[\n\r])+/g) || [])[0] || "";
                            return Z(pe);
                        }
                        function fe(H) {
                            H = typeof H == "string" ? H : "";
                            let pe = (H.match(/([\n\r][^\S\n\r]*)+$/g) || [])[0] || "";
                            return Z(pe);
                        }
                        function ge() {
                            let H = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
                            return Array.from({
                                length: Math.min(H, o)
                            }).fill(n);
                        }
                        function he(H, pe) {
                            let { quote: X, regex: le } = c(H, pe);
                            return [
                                X,
                                H.replace(le, `\\${X}`),
                                X
                            ];
                        }
                        function we(H) {
                            let pe = 0, X = H.getParentNode(pe);
                            for(; X && $(X, [
                                "SubExpression"
                            ]);)pe++, X = H.getParentNode(pe);
                            return !!(X && $(H.getParentNode(pe + 1), [
                                "ConcatStatement"
                            ]) && $(H.getParentNode(pe + 2), [
                                "AttrNode"
                            ]));
                        }
                        function ke(H, pe) {
                            let X = Ne(H, pe), le = Pe(H, pe);
                            return le ? i([
                                X,
                                p,
                                a2(le)
                            ]) : X;
                        }
                        function Re(H, pe) {
                            let X = Ne(H, pe), le = Pe(H, pe);
                            return le ? [
                                i([
                                    X,
                                    p,
                                    le
                                ]),
                                y
                            ] : X;
                        }
                        function Ne(H, pe) {
                            return pe("path");
                        }
                        function Pe(H, pe) {
                            let X = H.getValue(), le = [];
                            if (X.params.length > 0) {
                                let Ae = H.map(pe, "params");
                                le.push(...Ae);
                            }
                            if (X.hash && X.hash.pairs.length > 0) {
                                let Ae = pe("hash");
                                le.push(Ae);
                            }
                            return le.length === 0 ? "" : l(p, le);
                        }
                        function oe(H) {
                            return [
                                "as |",
                                H.blockParams.join(" "),
                                "|"
                            ];
                        }
                        r.exports = {
                            print: d,
                            massageAstNode: w
                        };
                    }
                }), Qd = te({
                    "src/language-handlebars/parsers.js" () {
                        ne();
                    }
                }), Zd = te({
                    "node_modules/linguist-languages/data/Handlebars.json" (e, r) {
                        r.exports = {
                            name: "Handlebars",
                            type: "markup",
                            color: "#f7931e",
                            aliases: [
                                "hbs",
                                "htmlbars"
                            ],
                            extensions: [
                                ".handlebars",
                                ".hbs"
                            ],
                            tmScope: "text.html.handlebars",
                            aceMode: "handlebars",
                            languageId: 155
                        };
                    }
                }), eg = te({
                    "src/language-handlebars/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = _t(), s = Yd(), a2 = Qd(), n = [
                            t1(Zd(), ()=>({
                                    since: "2.3.0",
                                    parsers: [
                                        "glimmer"
                                    ],
                                    vscodeLanguageIds: [
                                        "handlebars"
                                    ]
                                }))
                        ], u = {
                            glimmer: s
                        };
                        r.exports = {
                            languages: n,
                            printers: u,
                            parsers: a2
                        };
                    }
                }), tg = te({
                    "src/language-graphql/pragma.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(a2) {
                            return /^\s*#[^\S\n]*@(?:format|prettier)\s*(?:\n|$)/.test(a2);
                        }
                        function s(a2) {
                            return `# @format

` + a2;
                        }
                        r.exports = {
                            hasPragma: t1,
                            insertPragma: s
                        };
                    }
                }), rg = te({
                    "src/language-graphql/loc.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(a2) {
                            return typeof a2.start == "number" ? a2.start : a2.loc && a2.loc.start;
                        }
                        function s(a2) {
                            return typeof a2.end == "number" ? a2.end : a2.loc && a2.loc.end;
                        }
                        r.exports = {
                            locStart: t1,
                            locEnd: s
                        };
                    }
                }), ng = te({
                    "src/language-graphql/printer-graphql.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { join: t1, hardline: s, line: a2, softline: n, group: u, indent: i, ifBreak: l } } = qe(), { isNextLineEmpty: p, isNonEmptyArray: y } = Ue(), { insertPragma: h } = tg(), { locStart: g, locEnd: c } = rg();
                        function f2(P, $, D) {
                            let T = P.getValue();
                            if (!T) return "";
                            if (typeof T == "string") return T;
                            switch(T.kind){
                                case "Document":
                                    {
                                        let m = [];
                                        return P.each((C, o, d)=>{
                                            m.push(D()), o !== d.length - 1 && (m.push(s), p($.originalText, C.getValue(), c) && m.push(s));
                                        }, "definitions"), [
                                            ...m,
                                            s
                                        ];
                                    }
                                case "OperationDefinition":
                                    {
                                        let m = $.originalText[g(T)] !== "{", C = Boolean(T.name);
                                        return [
                                            m ? T.operation : "",
                                            m && C ? [
                                                " ",
                                                D("name")
                                            ] : "",
                                            m && !C && y(T.variableDefinitions) ? " " : "",
                                            y(T.variableDefinitions) ? u([
                                                "(",
                                                i([
                                                    n,
                                                    t1([
                                                        l("", ", "),
                                                        n
                                                    ], P.map(D, "variableDefinitions"))
                                                ]),
                                                n,
                                                ")"
                                            ]) : "",
                                            F(P, D, T),
                                            T.selectionSet ? !m && !C ? "" : " " : "",
                                            D("selectionSet")
                                        ];
                                    }
                                case "FragmentDefinition":
                                    return [
                                        "fragment ",
                                        D("name"),
                                        y(T.variableDefinitions) ? u([
                                            "(",
                                            i([
                                                n,
                                                t1([
                                                    l("", ", "),
                                                    n
                                                ], P.map(D, "variableDefinitions"))
                                            ]),
                                            n,
                                            ")"
                                        ]) : "",
                                        " on ",
                                        D("typeCondition"),
                                        F(P, D, T),
                                        " ",
                                        D("selectionSet")
                                    ];
                                case "SelectionSet":
                                    return [
                                        "{",
                                        i([
                                            s,
                                            t1(s, _2(P, $, D, "selections"))
                                        ]),
                                        s,
                                        "}"
                                    ];
                                case "Field":
                                    return u([
                                        T.alias ? [
                                            D("alias"),
                                            ": "
                                        ] : "",
                                        D("name"),
                                        T.arguments.length > 0 ? u([
                                            "(",
                                            i([
                                                n,
                                                t1([
                                                    l("", ", "),
                                                    n
                                                ], _2(P, $, D, "arguments"))
                                            ]),
                                            n,
                                            ")"
                                        ]) : "",
                                        F(P, D, T),
                                        T.selectionSet ? " " : "",
                                        D("selectionSet")
                                    ]);
                                case "Name":
                                    return T.value;
                                case "StringValue":
                                    {
                                        if (T.block) {
                                            let m = T.value.replace(/"""/g, "\\$&").split(`
`);
                                            return m.length === 1 && (m[0] = m[0].trim()), m.every((C)=>C === "") && (m.length = 0), t1(s, [
                                                '"""',
                                                ...m,
                                                '"""'
                                            ]);
                                        }
                                        return [
                                            '"',
                                            T.value.replace(/["\\]/g, "\\$&").replace(/\n/g, "\\n"),
                                            '"'
                                        ];
                                    }
                                case "IntValue":
                                case "FloatValue":
                                case "EnumValue":
                                    return T.value;
                                case "BooleanValue":
                                    return T.value ? "true" : "false";
                                case "NullValue":
                                    return "null";
                                case "Variable":
                                    return [
                                        "$",
                                        D("name")
                                    ];
                                case "ListValue":
                                    return u([
                                        "[",
                                        i([
                                            n,
                                            t1([
                                                l("", ", "),
                                                n
                                            ], P.map(D, "values"))
                                        ]),
                                        n,
                                        "]"
                                    ]);
                                case "ObjectValue":
                                    return u([
                                        "{",
                                        $.bracketSpacing && T.fields.length > 0 ? " " : "",
                                        i([
                                            n,
                                            t1([
                                                l("", ", "),
                                                n
                                            ], P.map(D, "fields"))
                                        ]),
                                        n,
                                        l("", $.bracketSpacing && T.fields.length > 0 ? " " : ""),
                                        "}"
                                    ]);
                                case "ObjectField":
                                case "Argument":
                                    return [
                                        D("name"),
                                        ": ",
                                        D("value")
                                    ];
                                case "Directive":
                                    return [
                                        "@",
                                        D("name"),
                                        T.arguments.length > 0 ? u([
                                            "(",
                                            i([
                                                n,
                                                t1([
                                                    l("", ", "),
                                                    n
                                                ], _2(P, $, D, "arguments"))
                                            ]),
                                            n,
                                            ")"
                                        ]) : ""
                                    ];
                                case "NamedType":
                                    return D("name");
                                case "VariableDefinition":
                                    return [
                                        D("variable"),
                                        ": ",
                                        D("type"),
                                        T.defaultValue ? [
                                            " = ",
                                            D("defaultValue")
                                        ] : "",
                                        F(P, D, T)
                                    ];
                                case "ObjectTypeExtension":
                                case "ObjectTypeDefinition":
                                    return [
                                        D("description"),
                                        T.description ? s : "",
                                        T.kind === "ObjectTypeExtension" ? "extend " : "",
                                        "type ",
                                        D("name"),
                                        T.interfaces.length > 0 ? [
                                            " implements ",
                                            ...N(P, $, D)
                                        ] : "",
                                        F(P, D, T),
                                        T.fields.length > 0 ? [
                                            " {",
                                            i([
                                                s,
                                                t1(s, _2(P, $, D, "fields"))
                                            ]),
                                            s,
                                            "}"
                                        ] : ""
                                    ];
                                case "FieldDefinition":
                                    return [
                                        D("description"),
                                        T.description ? s : "",
                                        D("name"),
                                        T.arguments.length > 0 ? u([
                                            "(",
                                            i([
                                                n,
                                                t1([
                                                    l("", ", "),
                                                    n
                                                ], _2(P, $, D, "arguments"))
                                            ]),
                                            n,
                                            ")"
                                        ]) : "",
                                        ": ",
                                        D("type"),
                                        F(P, D, T)
                                    ];
                                case "DirectiveDefinition":
                                    return [
                                        D("description"),
                                        T.description ? s : "",
                                        "directive ",
                                        "@",
                                        D("name"),
                                        T.arguments.length > 0 ? u([
                                            "(",
                                            i([
                                                n,
                                                t1([
                                                    l("", ", "),
                                                    n
                                                ], _2(P, $, D, "arguments"))
                                            ]),
                                            n,
                                            ")"
                                        ]) : "",
                                        T.repeatable ? " repeatable" : "",
                                        " on ",
                                        t1(" | ", P.map(D, "locations"))
                                    ];
                                case "EnumTypeExtension":
                                case "EnumTypeDefinition":
                                    return [
                                        D("description"),
                                        T.description ? s : "",
                                        T.kind === "EnumTypeExtension" ? "extend " : "",
                                        "enum ",
                                        D("name"),
                                        F(P, D, T),
                                        T.values.length > 0 ? [
                                            " {",
                                            i([
                                                s,
                                                t1(s, _2(P, $, D, "values"))
                                            ]),
                                            s,
                                            "}"
                                        ] : ""
                                    ];
                                case "EnumValueDefinition":
                                    return [
                                        D("description"),
                                        T.description ? s : "",
                                        D("name"),
                                        F(P, D, T)
                                    ];
                                case "InputValueDefinition":
                                    return [
                                        D("description"),
                                        T.description ? T.description.block ? s : a2 : "",
                                        D("name"),
                                        ": ",
                                        D("type"),
                                        T.defaultValue ? [
                                            " = ",
                                            D("defaultValue")
                                        ] : "",
                                        F(P, D, T)
                                    ];
                                case "InputObjectTypeExtension":
                                case "InputObjectTypeDefinition":
                                    return [
                                        D("description"),
                                        T.description ? s : "",
                                        T.kind === "InputObjectTypeExtension" ? "extend " : "",
                                        "input ",
                                        D("name"),
                                        F(P, D, T),
                                        T.fields.length > 0 ? [
                                            " {",
                                            i([
                                                s,
                                                t1(s, _2(P, $, D, "fields"))
                                            ]),
                                            s,
                                            "}"
                                        ] : ""
                                    ];
                                case "SchemaExtension":
                                    return [
                                        "extend schema",
                                        F(P, D, T),
                                        ...T.operationTypes.length > 0 ? [
                                            " {",
                                            i([
                                                s,
                                                t1(s, _2(P, $, D, "operationTypes"))
                                            ]),
                                            s,
                                            "}"
                                        ] : []
                                    ];
                                case "SchemaDefinition":
                                    return [
                                        D("description"),
                                        T.description ? s : "",
                                        "schema",
                                        F(P, D, T),
                                        " {",
                                        T.operationTypes.length > 0 ? i([
                                            s,
                                            t1(s, _2(P, $, D, "operationTypes"))
                                        ]) : "",
                                        s,
                                        "}"
                                    ];
                                case "OperationTypeDefinition":
                                    return [
                                        D("operation"),
                                        ": ",
                                        D("type")
                                    ];
                                case "InterfaceTypeExtension":
                                case "InterfaceTypeDefinition":
                                    return [
                                        D("description"),
                                        T.description ? s : "",
                                        T.kind === "InterfaceTypeExtension" ? "extend " : "",
                                        "interface ",
                                        D("name"),
                                        T.interfaces.length > 0 ? [
                                            " implements ",
                                            ...N(P, $, D)
                                        ] : "",
                                        F(P, D, T),
                                        T.fields.length > 0 ? [
                                            " {",
                                            i([
                                                s,
                                                t1(s, _2(P, $, D, "fields"))
                                            ]),
                                            s,
                                            "}"
                                        ] : ""
                                    ];
                                case "FragmentSpread":
                                    return [
                                        "...",
                                        D("name"),
                                        F(P, D, T)
                                    ];
                                case "InlineFragment":
                                    return [
                                        "...",
                                        T.typeCondition ? [
                                            " on ",
                                            D("typeCondition")
                                        ] : "",
                                        F(P, D, T),
                                        " ",
                                        D("selectionSet")
                                    ];
                                case "UnionTypeExtension":
                                case "UnionTypeDefinition":
                                    return u([
                                        D("description"),
                                        T.description ? s : "",
                                        u([
                                            T.kind === "UnionTypeExtension" ? "extend " : "",
                                            "union ",
                                            D("name"),
                                            F(P, D, T),
                                            T.types.length > 0 ? [
                                                " =",
                                                l("", " "),
                                                i([
                                                    l([
                                                        a2,
                                                        "  "
                                                    ]),
                                                    t1([
                                                        a2,
                                                        "| "
                                                    ], P.map(D, "types"))
                                                ])
                                            ] : ""
                                        ])
                                    ]);
                                case "ScalarTypeExtension":
                                case "ScalarTypeDefinition":
                                    return [
                                        D("description"),
                                        T.description ? s : "",
                                        T.kind === "ScalarTypeExtension" ? "extend " : "",
                                        "scalar ",
                                        D("name"),
                                        F(P, D, T)
                                    ];
                                case "NonNullType":
                                    return [
                                        D("type"),
                                        "!"
                                    ];
                                case "ListType":
                                    return [
                                        "[",
                                        D("type"),
                                        "]"
                                    ];
                                default:
                                    throw new Error("unknown graphql type: " + JSON.stringify(T.kind));
                            }
                        }
                        function F(P, $, D) {
                            if (D.directives.length === 0) return "";
                            let T = t1(a2, P.map($, "directives"));
                            return D.kind === "FragmentDefinition" || D.kind === "OperationDefinition" ? u([
                                a2,
                                T
                            ]) : [
                                " ",
                                u(i([
                                    n,
                                    T
                                ]))
                            ];
                        }
                        function _2(P, $, D, T) {
                            return P.map((m, C, o)=>{
                                let d = D();
                                return C < o.length - 1 && p($.originalText, m.getValue(), c) ? [
                                    d,
                                    s
                                ] : d;
                            }, T);
                        }
                        function w(P) {
                            return P.kind && P.kind !== "Comment";
                        }
                        function E(P) {
                            let $ = P.getValue();
                            if ($.kind === "Comment") return "#" + $.value.trimEnd();
                            throw new Error("Not a comment: " + JSON.stringify($));
                        }
                        function N(P, $, D) {
                            let T = P.getNode(), m = [], { interfaces: C } = T, o = P.map((d)=>D(d), "interfaces");
                            for(let d = 0; d < C.length; d++){
                                let v = C[d];
                                m.push(o[d]);
                                let S = C[d + 1];
                                if (S) {
                                    let b = $.originalText.slice(v.loc.end, S.loc.start), B = b.includes("#"), k = b.replace(/#.*/g, "").trim();
                                    m.push(k === "," ? "," : " &", B ? a2 : " ");
                                }
                            }
                            return m;
                        }
                        function x(P, $) {
                            P.kind === "StringValue" && P.block && !P.value.includes(`
`) && ($.value = $.value.trim());
                        }
                        x.ignoredProperties = /* @__PURE__ */ new Set([
                            "loc",
                            "comments"
                        ]);
                        function I(P) {
                            var $;
                            let D = P.getValue();
                            return D == null || ($ = D.comments) === null || $ === void 0 ? void 0 : $.some((T)=>T.value.trim() === "prettier-ignore");
                        }
                        r.exports = {
                            print: f2,
                            massageAstNode: x,
                            hasPrettierIgnore: I,
                            insertPragma: h,
                            printComment: E,
                            canAttachComment: w
                        };
                    }
                }), ug = te({
                    "src/language-graphql/options.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Mt();
                        r.exports = {
                            bracketSpacing: t1.bracketSpacing
                        };
                    }
                }), sg = te({
                    "src/language-graphql/parsers.js" () {
                        ne();
                    }
                }), ig = te({
                    "node_modules/linguist-languages/data/GraphQL.json" (e, r) {
                        r.exports = {
                            name: "GraphQL",
                            type: "data",
                            color: "#e10098",
                            extensions: [
                                ".graphql",
                                ".gql",
                                ".graphqls"
                            ],
                            tmScope: "source.graphql",
                            aceMode: "text",
                            languageId: 139
                        };
                    }
                }), ag = te({
                    "src/language-graphql/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = _t(), s = ng(), a2 = ug(), n = sg(), u = [
                            t1(ig(), ()=>({
                                    since: "1.5.0",
                                    parsers: [
                                        "graphql"
                                    ],
                                    vscodeLanguageIds: [
                                        "graphql"
                                    ]
                                }))
                        ], i = {
                            graphql: s
                        };
                        r.exports = {
                            languages: u,
                            options: a2,
                            printers: i,
                            parsers: n
                        };
                    }
                }), Po = te({
                    "node_modules/collapse-white-space/index.js" (e, r) {
                        "use strict";
                        ne(), r.exports = t1;
                        function t1(s) {
                            return String(s).replace(/\s+/g, " ");
                        }
                    }
                }), Io = te({
                    "src/language-markdown/loc.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(a2) {
                            return a2.position.start.offset;
                        }
                        function s(a2) {
                            return a2.position.end.offset;
                        }
                        r.exports = {
                            locStart: t1,
                            locEnd: s
                        };
                    }
                }), og = te({
                    "src/language-markdown/constants.evaluate.js" (e, r) {
                        r.exports = {
                            cjkPattern: "(?:[\\u02ea-\\u02eb\\u1100-\\u11ff\\u2e80-\\u2e99\\u2e9b-\\u2ef3\\u2f00-\\u2fd5\\u2ff0-\\u303f\\u3041-\\u3096\\u3099-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u3190-\\u3191\\u3196-\\u31ba\\u31c0-\\u31e3\\u31f0-\\u321e\\u322a-\\u3247\\u3260-\\u327e\\u328a-\\u32b0\\u32c0-\\u32cb\\u32d0-\\u3370\\u337b-\\u337f\\u33e0-\\u33fe\\u3400-\\u4db5\\u4e00-\\u9fef\\ua960-\\ua97c\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufe10-\\ufe1f\\ufe30-\\ufe6f\\uff00-\\uffef]|[\\ud840-\\ud868\\ud86a-\\ud86c\\ud86f-\\ud872\\ud874-\\ud879][\\udc00-\\udfff]|\\ud82c[\\udc00-\\udd1e\\udd50-\\udd52\\udd64-\\udd67]|\\ud83c[\\ude00\\ude50-\\ude51]|\\ud869[\\udc00-\\uded6\\udf00-\\udfff]|\\ud86d[\\udc00-\\udf34\\udf40-\\udfff]|\\ud86e[\\udc00-\\udc1d\\udc20-\\udfff]|\\ud873[\\udc00-\\udea1\\udeb0-\\udfff]|\\ud87a[\\udc00-\\udfe0]|\\ud87e[\\udc00-\\ude1d])(?:[\\ufe00-\\ufe0f]|\\udb40[\\udd00-\\uddef])?",
                            kPattern: "[\\u1100-\\u11ff\\u3001-\\u3003\\u3008-\\u3011\\u3013-\\u301f\\u302e-\\u3030\\u3037\\u30fb\\u3131-\\u318e\\u3200-\\u321e\\u3260-\\u327e\\ua960-\\ua97c\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\ufe45-\\ufe46\\uff61-\\uff65\\uffa0-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc]",
                            punctuationPattern: "[\\u0021-\\u002f\\u003a-\\u0040\\u005b-\\u0060\\u007b-\\u007e\\u00a1\\u00a7\\u00ab\\u00b6-\\u00b7\\u00bb\\u00bf\\u037e\\u0387\\u055a-\\u055f\\u0589-\\u058a\\u05be\\u05c0\\u05c3\\u05c6\\u05f3-\\u05f4\\u0609-\\u060a\\u060c-\\u060d\\u061b\\u061e-\\u061f\\u066a-\\u066d\\u06d4\\u0700-\\u070d\\u07f7-\\u07f9\\u0830-\\u083e\\u085e\\u0964-\\u0965\\u0970\\u09fd\\u0a76\\u0af0\\u0c77\\u0c84\\u0df4\\u0e4f\\u0e5a-\\u0e5b\\u0f04-\\u0f12\\u0f14\\u0f3a-\\u0f3d\\u0f85\\u0fd0-\\u0fd4\\u0fd9-\\u0fda\\u104a-\\u104f\\u10fb\\u1360-\\u1368\\u1400\\u166e\\u169b-\\u169c\\u16eb-\\u16ed\\u1735-\\u1736\\u17d4-\\u17d6\\u17d8-\\u17da\\u1800-\\u180a\\u1944-\\u1945\\u1a1e-\\u1a1f\\u1aa0-\\u1aa6\\u1aa8-\\u1aad\\u1b5a-\\u1b60\\u1bfc-\\u1bff\\u1c3b-\\u1c3f\\u1c7e-\\u1c7f\\u1cc0-\\u1cc7\\u1cd3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205e\\u207d-\\u207e\\u208d-\\u208e\\u2308-\\u230b\\u2329-\\u232a\\u2768-\\u2775\\u27c5-\\u27c6\\u27e6-\\u27ef\\u2983-\\u2998\\u29d8-\\u29db\\u29fc-\\u29fd\\u2cf9-\\u2cfc\\u2cfe-\\u2cff\\u2d70\\u2e00-\\u2e2e\\u2e30-\\u2e4f\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301f\\u3030\\u303d\\u30a0\\u30fb\\ua4fe-\\ua4ff\\ua60d-\\ua60f\\ua673\\ua67e\\ua6f2-\\ua6f7\\ua874-\\ua877\\ua8ce-\\ua8cf\\ua8f8-\\ua8fa\\ua8fc\\ua92e-\\ua92f\\ua95f\\ua9c1-\\ua9cd\\ua9de-\\ua9df\\uaa5c-\\uaa5f\\uaade-\\uaadf\\uaaf0-\\uaaf1\\uabeb\\ufd3e-\\ufd3f\\ufe10-\\ufe19\\ufe30-\\ufe52\\ufe54-\\ufe61\\ufe63\\ufe68\\ufe6a-\\ufe6b\\uff01-\\uff03\\uff05-\\uff0a\\uff0c-\\uff0f\\uff1a-\\uff1b\\uff1f-\\uff20\\uff3b-\\uff3d\\uff3f\\uff5b\\uff5d\\uff5f-\\uff65]|\\ud800[\\udd00-\\udd02\\udf9f\\udfd0]|\\ud801[\\udd6f]|\\ud802[\\udc57\\udd1f\\udd3f\\ude50-\\ude58\\ude7f\\udef0-\\udef6\\udf39-\\udf3f\\udf99-\\udf9c]|\\ud803[\\udf55-\\udf59]|\\ud804[\\udc47-\\udc4d\\udcbb-\\udcbc\\udcbe-\\udcc1\\udd40-\\udd43\\udd74-\\udd75\\uddc5-\\uddc8\\uddcd\\udddb\\udddd-\\udddf\\ude38-\\ude3d\\udea9]|\\ud805[\\udc4b-\\udc4f\\udc5b\\udc5d\\udcc6\\uddc1-\\uddd7\\ude41-\\ude43\\ude60-\\ude6c\\udf3c-\\udf3e]|\\ud806[\\udc3b\\udde2\\ude3f-\\ude46\\ude9a-\\ude9c\\ude9e-\\udea2]|\\ud807[\\udc41-\\udc45\\udc70-\\udc71\\udef7-\\udef8\\udfff]|\\ud809[\\udc70-\\udc74]|\\ud81a[\\ude6e-\\ude6f\\udef5\\udf37-\\udf3b\\udf44]|\\ud81b[\\ude97-\\ude9a\\udfe2]|\\ud82f[\\udc9f]|\\ud836[\\ude87-\\ude8b]|\\ud83a[\\udd5e-\\udd5f]"
                        };
                    }
                }), iu = te({
                    "src/language-markdown/utils.js" (e, r) {
                        "use strict";
                        ne();
                        var { getLast: t1 } = Ue(), { locStart: s, locEnd: a2 } = Io(), { cjkPattern: n, kPattern: u, punctuationPattern: i } = og(), l = [
                            "liquidNode",
                            "inlineCode",
                            "emphasis",
                            "esComment",
                            "strong",
                            "delete",
                            "wikiLink",
                            "link",
                            "linkReference",
                            "image",
                            "imageReference",
                            "footnote",
                            "footnoteReference",
                            "sentence",
                            "whitespace",
                            "word",
                            "break",
                            "inlineMath"
                        ], p = [
                            ...l,
                            "tableCell",
                            "paragraph",
                            "heading"
                        ], y = new RegExp(u), h = new RegExp(i);
                        function g(E, N) {
                            let x = "non-cjk", I = "cj-letter", P = "k-letter", $ = "cjk-punctuation", D = [], T = (N.proseWrap === "preserve" ? E : E.replace(new RegExp(`(${n})
(${n})`, "g"), "$1$2")).split(/([\t\n ]+)/);
                            for (let [C, o] of T.entries()){
                                if (C % 2 === 1) {
                                    D.push({
                                        type: "whitespace",
                                        value: /\n/.test(o) ? `
` : " "
                                    });
                                    continue;
                                }
                                if ((C === 0 || C === T.length - 1) && o === "") continue;
                                let d = o.split(new RegExp(`(${n})`));
                                for (let [v, S] of d.entries())if (!((v === 0 || v === d.length - 1) && S === "")) {
                                    if (v % 2 === 0) {
                                        S !== "" && m({
                                            type: "word",
                                            value: S,
                                            kind: x,
                                            hasLeadingPunctuation: h.test(S[0]),
                                            hasTrailingPunctuation: h.test(t1(S))
                                        });
                                        continue;
                                    }
                                    m(h.test(S) ? {
                                        type: "word",
                                        value: S,
                                        kind: $,
                                        hasLeadingPunctuation: true,
                                        hasTrailingPunctuation: true
                                    } : {
                                        type: "word",
                                        value: S,
                                        kind: y.test(S) ? P : I,
                                        hasLeadingPunctuation: false,
                                        hasTrailingPunctuation: false
                                    });
                                }
                            }
                            return D;
                            function m(C) {
                                let o = t1(D);
                                o && o.type === "word" && (o.kind === x && C.kind === I && !o.hasTrailingPunctuation || o.kind === I && C.kind === x && !C.hasLeadingPunctuation ? D.push({
                                    type: "whitespace",
                                    value: " "
                                }) : !d(x, $) && ![
                                    o.value,
                                    C.value
                                ].some((v)=>/\u3000/.test(v)) && D.push({
                                    type: "whitespace",
                                    value: ""
                                })), D.push(C);
                                function d(v, S) {
                                    return o.kind === v && C.kind === S || o.kind === S && C.kind === v;
                                }
                            }
                        }
                        function c(E, N) {
                            let [, x, I, P] = N.slice(E.position.start.offset, E.position.end.offset).match(/^\s*(\d+)(\.|\))(\s*)/);
                            return {
                                numberText: x,
                                marker: I,
                                leadingSpaces: P
                            };
                        }
                        function f2(E, N) {
                            if (!E.ordered || E.children.length < 2) return false;
                            let x = Number(c(E.children[0], N.originalText).numberText), I = Number(c(E.children[1], N.originalText).numberText);
                            if (x === 0 && E.children.length > 2) {
                                let P = Number(c(E.children[2], N.originalText).numberText);
                                return I === 1 && P === 1;
                            }
                            return I === 1;
                        }
                        function F(E, N) {
                            let { value: x } = E;
                            return E.position.end.offset === N.length && x.endsWith(`
`) && N.endsWith(`
`) ? x.slice(0, -1) : x;
                        }
                        function _2(E, N) {
                            return function x(I, P, $) {
                                let D = Object.assign({}, N(I, P, $));
                                return D.children && (D.children = D.children.map((T, m)=>x(T, m, [
                                        D,
                                        ...$
                                    ]))), D;
                            }(E, null, []);
                        }
                        function w(E) {
                            if ((E == null ? void 0 : E.type) !== "link" || E.children.length !== 1) return false;
                            let [N] = E.children;
                            return s(E) === s(N) && a2(E) === a2(N);
                        }
                        r.exports = {
                            mapAst: _2,
                            splitText: g,
                            punctuationPattern: i,
                            getFencedCodeBlockValue: F,
                            getOrderedListItemInfo: c,
                            hasGitDiffFriendlyOrderedList: f2,
                            INLINE_NODE_TYPES: l,
                            INLINE_NODE_WRAPPER_TYPES: p,
                            isAutolink: w
                        };
                    }
                }), lg = te({
                    "src/language-markdown/embed.js" (e, r) {
                        "use strict";
                        ne();
                        var { inferParserByLanguage: t1, getMaxContinuousCount: s } = Ue(), { builders: { hardline: a2, markAsRoot: n }, utils: { replaceEndOfLine: u } } = qe(), i = su(), { getFencedCodeBlockValue: l } = iu();
                        function p(y, h, g, c) {
                            let f2 = y.getValue();
                            if (f2.type === "code" && f2.lang !== null) {
                                let F = t1(f2.lang, c);
                                if (F) {
                                    let _2 = c.__inJsTemplate ? "~" : "`", w = _2.repeat(Math.max(3, s(f2.value, _2) + 1)), E = {
                                        parser: F
                                    };
                                    f2.lang === "tsx" && (E.filepath = "dummy.tsx");
                                    let N = g(l(f2, c.originalText), E, {
                                        stripTrailingHardline: true
                                    });
                                    return n([
                                        w,
                                        f2.lang,
                                        f2.meta ? " " + f2.meta : "",
                                        a2,
                                        u(N),
                                        a2,
                                        w
                                    ]);
                                }
                            }
                            switch(f2.type){
                                case "front-matter":
                                    return i(f2, g);
                                case "importExport":
                                    return [
                                        g(f2.value, {
                                            parser: "babel"
                                        }, {
                                            stripTrailingHardline: true
                                        }),
                                        a2
                                    ];
                                case "jsx":
                                    return g(`<$>${f2.value}</$>`, {
                                        parser: "__js_expression",
                                        rootMarker: "mdx"
                                    }, {
                                        stripTrailingHardline: true
                                    });
                            }
                            return null;
                        }
                        r.exports = p;
                    }
                }), ko = te({
                    "src/language-markdown/pragma.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = _o(), s = [
                            "format",
                            "prettier"
                        ];
                        function a2(n) {
                            let u = `@(${s.join("|")})`, i = new RegExp([
                                `<!--\\s*${u}\\s*-->`,
                                `{\\s*\\/\\*\\s*${u}\\s*\\*\\/\\s*}`,
                                `<!--.*\r?
[\\s\\S]*(^|
)[^\\S
]*${u}[^\\S
]*($|
)[\\s\\S]*
.*-->`
                            ].join("|"), "m"), l = n.match(i);
                            return (l == null ? void 0 : l.index) === 0;
                        }
                        r.exports = {
                            startWithPragma: a2,
                            hasPragma: (n)=>a2(t1(n).content.trimStart()),
                            insertPragma: (n)=>{
                                let u = t1(n), i = `<!-- @${s[0]} -->`;
                                return u.frontMatter ? `${u.frontMatter.raw}

${i}

${u.content}` : `${i}

${u.content}`;
                            }
                        };
                    }
                }), cg = te({
                    "src/language-markdown/print-preprocess.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = lt(), { getOrderedListItemInfo: s, mapAst: a2, splitText: n } = iu(), u = RegExp("^.$", "su");
                        function i(w, E) {
                            return w = y(w, E), w = c(w), w = p(w, E), w = F(w, E), w = _2(w, E), w = f2(w, E), w = l(w), w = h(w), w;
                        }
                        function l(w) {
                            return a2(w, (E)=>E.type !== "import" && E.type !== "export" ? E : Object.assign(Object.assign({}, E), {}, {
                                    type: "importExport"
                                }));
                        }
                        function p(w, E) {
                            return a2(w, (N)=>N.type !== "inlineCode" || E.proseWrap === "preserve" ? N : Object.assign(Object.assign({}, N), {}, {
                                    value: N.value.replace(/\s+/g, " ")
                                }));
                        }
                        function y(w, E) {
                            return a2(w, (N)=>N.type !== "text" || N.value === "*" || N.value === "_" || !u.test(N.value) || N.position.end.offset - N.position.start.offset === N.value.length ? N : Object.assign(Object.assign({}, N), {}, {
                                    value: E.originalText.slice(N.position.start.offset, N.position.end.offset)
                                }));
                        }
                        function h(w) {
                            return g(w, (E, N)=>E.type === "importExport" && N.type === "importExport", (E, N)=>({
                                    type: "importExport",
                                    value: E.value + `

` + N.value,
                                    position: {
                                        start: E.position.start,
                                        end: N.position.end
                                    }
                                }));
                        }
                        function g(w, E, N) {
                            return a2(w, (x)=>{
                                if (!x.children) return x;
                                let I = x.children.reduce((P, $)=>{
                                    let D = t1(P);
                                    return D && E(D, $) ? P.splice(-1, 1, N(D, $)) : P.push($), P;
                                }, []);
                                return Object.assign(Object.assign({}, x), {}, {
                                    children: I
                                });
                            });
                        }
                        function c(w) {
                            return g(w, (E, N)=>E.type === "text" && N.type === "text", (E, N)=>({
                                    type: "text",
                                    value: E.value + N.value,
                                    position: {
                                        start: E.position.start,
                                        end: N.position.end
                                    }
                                }));
                        }
                        function f2(w, E) {
                            return a2(w, (N, x, I)=>{
                                let [P] = I;
                                if (N.type !== "text") return N;
                                let { value: $ } = N;
                                return P.type === "paragraph" && (x === 0 && ($ = $.trimStart()), x === P.children.length - 1 && ($ = $.trimEnd())), {
                                    type: "sentence",
                                    position: N.position,
                                    children: n($, E)
                                };
                            });
                        }
                        function F(w, E) {
                            return a2(w, (N, x, I)=>{
                                if (N.type === "code") {
                                    let P = /^\n?(?: {4,}|\t)/.test(E.originalText.slice(N.position.start.offset, N.position.end.offset));
                                    if (N.isIndented = P, P) for(let $ = 0; $ < I.length; $++){
                                        let D = I[$];
                                        if (D.hasIndentedCodeblock) break;
                                        D.type === "list" && (D.hasIndentedCodeblock = true);
                                    }
                                }
                                return N;
                            });
                        }
                        function _2(w, E) {
                            return a2(w, (I, P, $)=>{
                                if (I.type === "list" && I.children.length > 0) {
                                    for(let D = 0; D < $.length; D++){
                                        let T = $[D];
                                        if (T.type === "list" && !T.isAligned) return I.isAligned = false, I;
                                    }
                                    I.isAligned = x(I);
                                }
                                return I;
                            });
                            function N(I) {
                                return I.children.length === 0 ? -1 : I.children[0].position.start.column - 1;
                            }
                            function x(I) {
                                if (!I.ordered) return true;
                                let [P, $] = I.children;
                                if (s(P, E.originalText).leadingSpaces.length > 1) return true;
                                let T = N(P);
                                if (T === -1) return false;
                                if (I.children.length === 1) return T % E.tabWidth === 0;
                                let m = N($);
                                return T !== m ? false : T % E.tabWidth === 0 ? true : s($, E.originalText).leadingSpaces.length > 1;
                            }
                        }
                        r.exports = i;
                    }
                }), pg = te({
                    "src/language-markdown/clean.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Po(), { isFrontMatterNode: s } = Ue(), { startWithPragma: a2 } = ko(), n = /* @__PURE__ */ new Set([
                            "position",
                            "raw"
                        ]);
                        function u(i, l, p) {
                            if ((i.type === "front-matter" || i.type === "code" || i.type === "yaml" || i.type === "import" || i.type === "export" || i.type === "jsx") && delete l.value, i.type === "list" && delete l.isAligned, (i.type === "list" || i.type === "listItem") && (delete l.spread, delete l.loose), i.type === "text" || (i.type === "inlineCode" && (l.value = i.value.replace(/[\t\n ]+/g, " ")), i.type === "wikiLink" && (l.value = i.value.trim().replace(/[\t\n]+/g, " ")), (i.type === "definition" || i.type === "linkReference" || i.type === "imageReference") && (l.label = t1(i.label)), (i.type === "definition" || i.type === "link" || i.type === "image") && i.title && (l.title = i.title.replace(/\\(["')])/g, "$1")), p && p.type === "root" && p.children.length > 0 && (p.children[0] === i || s(p.children[0]) && p.children[1] === i) && i.type === "html" && a2(i.value))) return null;
                        }
                        u.ignoredProperties = n, r.exports = u;
                    }
                }), fg = te({
                    "src/language-markdown/printer-markdown.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Po(), { getLast: s, getMinNotPresentContinuousCount: a2, getMaxContinuousCount: n, getStringWidth: u, isNonEmptyArray: i } = Ue(), { builders: { breakParent: l, join: p, line: y, literalline: h, markAsRoot: g, hardline: c, softline: f2, ifBreak: F, fill: _2, align: w, indent: E, group: N, hardlineWithoutBreakParent: x }, utils: { normalizeDoc: I, replaceTextEndOfLine: P }, printer: { printDocToString: $ } } = qe(), D = lg(), { insertPragma: T } = ko(), { locStart: m, locEnd: C } = Io(), o = cg(), d = pg(), { getFencedCodeBlockValue: v, hasGitDiffFriendlyOrderedList: S, splitText: b, punctuationPattern: B, INLINE_NODE_TYPES: k, INLINE_NODE_WRAPPER_TYPES: M, isAutolink: R } = iu(), q = /* @__PURE__ */ new Set([
                            "importExport"
                        ]), J = [
                            "heading",
                            "tableCell",
                            "link",
                            "wikiLink"
                        ], L = /* @__PURE__ */ new Set([
                            "listItem",
                            "definition",
                            "footnoteDefinition"
                        ]);
                        function Q(oe, H, pe) {
                            let X = oe.getValue();
                            if (ge(oe)) return b(H.originalText.slice(X.position.start.offset, X.position.end.offset), H).map((le)=>le.type === "word" ? le.value : le.value === "" ? "" : W(oe, le.value, H));
                            switch(X.type){
                                case "front-matter":
                                    return H.originalText.slice(X.position.start.offset, X.position.end.offset);
                                case "root":
                                    return X.children.length === 0 ? "" : [
                                        I(de(oe, H, pe)),
                                        q.has(z(X).type) ? "" : c
                                    ];
                                case "paragraph":
                                    return ue(oe, H, pe, {
                                        postprocessor: _2
                                    });
                                case "sentence":
                                    return ue(oe, H, pe);
                                case "word":
                                    {
                                        let le = X.value.replace(/\*/g, "\\$&").replace(new RegExp([
                                            `(^|${B})(_+)`,
                                            `(_+)(${B}|$)`
                                        ].join("|"), "g"), (De, A2, G, re, ye)=>(G ? `${A2}${G}` : `${re}${ye}`).replace(/_/g, "\\_")), Ae = (De, A2, G)=>De.type === "sentence" && G === 0, Ee = (De, A2, G)=>R(De.children[G - 1]);
                                        return le !== X.value && (oe.match(void 0, Ae, Ee) || oe.match(void 0, Ae, (De, A2, G)=>De.type === "emphasis" && G === 0, Ee)) && (le = le.replace(/^(\\?[*_])+/, (De)=>De.replace(/\\/g, ""))), le;
                                    }
                                case "whitespace":
                                    {
                                        let le = oe.getParentNode(), Ae = le.children.indexOf(X), Ee = le.children[Ae + 1], De = Ee && /^>|^(?:[*+-]|#{1,6}|\d+[).])$/.test(Ee.value) ? "never" : H.proseWrap;
                                        return W(oe, X.value, {
                                            proseWrap: De
                                        });
                                    }
                                case "emphasis":
                                    {
                                        let le;
                                        if (R(X.children[0])) le = H.originalText[X.position.start.offset];
                                        else {
                                            let Ae = oe.getParentNode(), Ee = Ae.children.indexOf(X), De = Ae.children[Ee - 1], A2 = Ae.children[Ee + 1];
                                            le = De && De.type === "sentence" && De.children.length > 0 && s(De.children).type === "word" && !s(De.children).hasTrailingPunctuation || A2 && A2.type === "sentence" && A2.children.length > 0 && A2.children[0].type === "word" && !A2.children[0].hasLeadingPunctuation || ce(oe, "emphasis") ? "*" : "_";
                                        }
                                        return [
                                            le,
                                            ue(oe, H, pe),
                                            le
                                        ];
                                    }
                                case "strong":
                                    return [
                                        "**",
                                        ue(oe, H, pe),
                                        "**"
                                    ];
                                case "delete":
                                    return [
                                        "~~",
                                        ue(oe, H, pe),
                                        "~~"
                                    ];
                                case "inlineCode":
                                    {
                                        let le = a2(X.value, "`"), Ae = "`".repeat(le || 1), Ee = le && !/^\s/.test(X.value) ? " " : "";
                                        return [
                                            Ae,
                                            Ee,
                                            X.value,
                                            Ee,
                                            Ae
                                        ];
                                    }
                                case "wikiLink":
                                    {
                                        let le = "";
                                        return H.proseWrap === "preserve" ? le = X.value : le = X.value.replace(/[\t\n]+/g, " "), [
                                            "[[",
                                            le,
                                            "]]"
                                        ];
                                    }
                                case "link":
                                    switch(H.originalText[X.position.start.offset]){
                                        case "<":
                                            {
                                                let le = "mailto:";
                                                return [
                                                    "<",
                                                    X.url.startsWith(le) && H.originalText.slice(X.position.start.offset + 1, X.position.start.offset + 1 + le.length) !== le ? X.url.slice(le.length) : X.url,
                                                    ">"
                                                ];
                                            }
                                        case "[":
                                            return [
                                                "[",
                                                ue(oe, H, pe),
                                                "](",
                                                he(X.url, ")"),
                                                we(X.title, H),
                                                ")"
                                            ];
                                        default:
                                            return H.originalText.slice(X.position.start.offset, X.position.end.offset);
                                    }
                                case "image":
                                    return [
                                        "![",
                                        X.alt || "",
                                        "](",
                                        he(X.url, ")"),
                                        we(X.title, H),
                                        ")"
                                    ];
                                case "blockquote":
                                    return [
                                        "> ",
                                        w("> ", ue(oe, H, pe))
                                    ];
                                case "heading":
                                    return [
                                        "#".repeat(X.depth) + " ",
                                        ue(oe, H, pe)
                                    ];
                                case "code":
                                    {
                                        if (X.isIndented) {
                                            let Ee = " ".repeat(4);
                                            return w(Ee, [
                                                Ee,
                                                ...P(X.value, c)
                                            ]);
                                        }
                                        let le = H.__inJsTemplate ? "~" : "`", Ae = le.repeat(Math.max(3, n(X.value, le) + 1));
                                        return [
                                            Ae,
                                            X.lang || "",
                                            X.meta ? " " + X.meta : "",
                                            c,
                                            ...P(v(X, H.originalText), c),
                                            c,
                                            Ae
                                        ];
                                    }
                                case "html":
                                    {
                                        let le = oe.getParentNode(), Ae = le.type === "root" && s(le.children) === X ? X.value.trimEnd() : X.value, Ee = RegExp("^<!--.*-->$", "s").test(Ae);
                                        return P(Ae, Ee ? c : g(h));
                                    }
                                case "list":
                                    {
                                        let le = Y(X, oe.getParentNode()), Ae = S(X, H);
                                        return ue(oe, H, pe, {
                                            processor: (Ee, De)=>{
                                                let A2 = re(), G = Ee.getValue();
                                                if (G.children.length === 2 && G.children[1].type === "html" && G.children[0].position.start.column !== G.children[1].position.start.column) return [
                                                    A2,
                                                    V(Ee, H, pe, A2)
                                                ];
                                                return [
                                                    A2,
                                                    w(" ".repeat(A2.length), V(Ee, H, pe, A2))
                                                ];
                                                function re() {
                                                    let ye = X.ordered ? (De === 0 ? X.start : Ae ? 1 : X.start + De) + (le % 2 === 0 ? ". " : ") ") : le % 2 === 0 ? "- " : "* ";
                                                    return X.isAligned || X.hasIndentedCodeblock ? j(ye, H) : ye;
                                                }
                                            }
                                        });
                                    }
                                case "thematicBreak":
                                    {
                                        let le = ee(oe, "list");
                                        return le === -1 ? "---" : Y(oe.getParentNode(le), oe.getParentNode(le + 1)) % 2 === 0 ? "***" : "---";
                                    }
                                case "linkReference":
                                    return [
                                        "[",
                                        ue(oe, H, pe),
                                        "]",
                                        X.referenceType === "full" ? Ne(X) : X.referenceType === "collapsed" ? "[]" : ""
                                    ];
                                case "imageReference":
                                    switch(X.referenceType){
                                        case "full":
                                            return [
                                                "![",
                                                X.alt || "",
                                                "]",
                                                Ne(X)
                                            ];
                                        default:
                                            return [
                                                "![",
                                                X.alt,
                                                "]",
                                                X.referenceType === "collapsed" ? "[]" : ""
                                            ];
                                    }
                                case "definition":
                                    {
                                        let le = H.proseWrap === "always" ? y : " ";
                                        return N([
                                            Ne(X),
                                            ":",
                                            E([
                                                le,
                                                he(X.url),
                                                X.title === null ? "" : [
                                                    le,
                                                    we(X.title, H, false)
                                                ]
                                            ])
                                        ]);
                                    }
                                case "footnote":
                                    return [
                                        "[^",
                                        ue(oe, H, pe),
                                        "]"
                                    ];
                                case "footnoteReference":
                                    return Pe(X);
                                case "footnoteDefinition":
                                    {
                                        let le = oe.getParentNode().children[oe.getName() + 1], Ae = X.children.length === 1 && X.children[0].type === "paragraph" && (H.proseWrap === "never" || H.proseWrap === "preserve" && X.children[0].position.start.line === X.children[0].position.end.line);
                                        return [
                                            Pe(X),
                                            ": ",
                                            Ae ? ue(oe, H, pe) : N([
                                                w(" ".repeat(4), ue(oe, H, pe, {
                                                    processor: (Ee, De)=>De === 0 ? N([
                                                            f2,
                                                            pe()
                                                        ]) : pe()
                                                })),
                                                le && le.type === "footnoteDefinition" ? f2 : ""
                                            ])
                                        ];
                                    }
                                case "table":
                                    return K(oe, H, pe);
                                case "tableCell":
                                    return ue(oe, H, pe);
                                case "break":
                                    return /\s/.test(H.originalText[X.position.start.offset]) ? [
                                        "  ",
                                        g(h)
                                    ] : [
                                        "\\",
                                        c
                                    ];
                                case "liquidNode":
                                    return P(X.value, c);
                                case "importExport":
                                    return [
                                        X.value,
                                        c
                                    ];
                                case "esComment":
                                    return [
                                        "{/* ",
                                        X.value,
                                        " */}"
                                    ];
                                case "jsx":
                                    return X.value;
                                case "math":
                                    return [
                                        "$$",
                                        c,
                                        X.value ? [
                                            ...P(X.value, c),
                                            c
                                        ] : "",
                                        "$$"
                                    ];
                                case "inlineMath":
                                    return H.originalText.slice(m(X), C(X));
                                case "tableRow":
                                case "listItem":
                                default:
                                    throw new Error(`Unknown markdown type ${JSON.stringify(X.type)}`);
                            }
                        }
                        function V(oe, H, pe, X) {
                            let le = oe.getValue(), Ae = le.checked === null ? "" : le.checked ? "[x] " : "[ ] ";
                            return [
                                Ae,
                                ue(oe, H, pe, {
                                    processor: (Ee, De)=>{
                                        if (De === 0 && Ee.getValue().type !== "list") return w(" ".repeat(Ae.length), pe());
                                        let A2 = " ".repeat(ke(H.tabWidth - X.length, 0, 3));
                                        return [
                                            A2,
                                            w(A2, pe())
                                        ];
                                    }
                                })
                            ];
                        }
                        function j(oe, H) {
                            let pe = X();
                            return oe + " ".repeat(pe >= 4 ? 0 : pe);
                            function X() {
                                let le = oe.length % H.tabWidth;
                                return le === 0 ? 0 : H.tabWidth - le;
                            }
                        }
                        function Y(oe, H) {
                            return ie(oe, H, (pe)=>pe.ordered === oe.ordered);
                        }
                        function ie(oe, H, pe) {
                            let X = -1;
                            for (let le of H.children)if (le.type === oe.type && pe(le) ? X++ : X = -1, le === oe) return X;
                        }
                        function ee(oe, H) {
                            let pe = Array.isArray(H) ? H : [
                                H
                            ], X = -1, le;
                            for(; le = oe.getParentNode(++X);)if (pe.includes(le.type)) return X;
                            return -1;
                        }
                        function ce(oe, H) {
                            let pe = ee(oe, H);
                            return pe === -1 ? null : oe.getParentNode(pe);
                        }
                        function W(oe, H, pe) {
                            if (pe.proseWrap === "preserve" && H === `
`) return c;
                            let X = pe.proseWrap === "always" && !ce(oe, J);
                            return H !== "" ? X ? y : " " : X ? f2 : "";
                        }
                        function K(oe, H, pe) {
                            let X = oe.getValue(), le = [], Ae = oe.map((ye)=>ye.map((Ce, Be)=>{
                                    let ve = $(pe(), H).formatted, ze = u(ve);
                                    return le[Be] = Math.max(le[Be] || 3, ze), {
                                        text: ve,
                                        width: ze
                                    };
                                }, "children"), "children"), Ee = A2(false);
                            if (H.proseWrap !== "never") return [
                                l,
                                Ee
                            ];
                            let De = A2(true);
                            return [
                                l,
                                N(F(De, Ee))
                            ];
                            function A2(ye) {
                                let Ce = [
                                    re(Ae[0], ye),
                                    G(ye)
                                ];
                                return Ae.length > 1 && Ce.push(p(x, Ae.slice(1).map((Be)=>re(Be, ye)))), p(x, Ce);
                            }
                            function G(ye) {
                                return `| ${le.map((Be, ve)=>{
                                    let ze = X.align[ve], be = ze === "center" || ze === "left" ? ":" : "-", Ye = ze === "center" || ze === "right" ? ":" : "-", Se = ye ? "-" : "-".repeat(Be - 2);
                                    return `${be}${Se}${Ye}`;
                                }).join(" | ")} |`;
                            }
                            function re(ye, Ce) {
                                return `| ${ye.map((ve, ze)=>{
                                    let { text: be, width: Ye } = ve;
                                    if (Ce) return be;
                                    let Se = le[ze] - Ye, Ie = X.align[ze], Oe = 0;
                                    Ie === "right" ? Oe = Se : Ie === "center" && (Oe = Math.floor(Se / 2));
                                    let Je = Se - Oe;
                                    return `${" ".repeat(Oe)}${be}${" ".repeat(Je)}`;
                                }).join(" | ")} |`;
                            }
                        }
                        function de(oe, H, pe) {
                            let X = [], le = null, { children: Ae } = oe.getValue();
                            for (let [Ee, De] of Ae.entries())switch(U(De)){
                                case "start":
                                    le === null && (le = {
                                        index: Ee,
                                        offset: De.position.end.offset
                                    });
                                    break;
                                case "end":
                                    le !== null && (X.push({
                                        start: le,
                                        end: {
                                            index: Ee,
                                            offset: De.position.start.offset
                                        }
                                    }), le = null);
                                    break;
                                default:
                                    break;
                            }
                            return ue(oe, H, pe, {
                                processor: (Ee, De)=>{
                                    if (X.length > 0) {
                                        let A2 = X[0];
                                        if (De === A2.start.index) return [
                                            Fe(Ae[A2.start.index]),
                                            H.originalText.slice(A2.start.offset, A2.end.offset),
                                            Fe(Ae[A2.end.index])
                                        ];
                                        if (A2.start.index < De && De < A2.end.index) return false;
                                        if (De === A2.end.index) return X.shift(), false;
                                    }
                                    return pe();
                                }
                            });
                        }
                        function ue(oe, H, pe) {
                            let X = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {}, { postprocessor: le } = X, Ae = X.processor || (()=>pe()), Ee = oe.getValue(), De = [], A2;
                            return oe.each((G, re)=>{
                                let ye = G.getValue(), Ce = Ae(G, re);
                                if (Ce !== false) {
                                    let Be = {
                                        parts: De,
                                        prevNode: A2,
                                        parentNode: Ee,
                                        options: H
                                    };
                                    Z(ye, Be) && (De.push(c), A2 && q.has(A2.type) || (se(ye, Be) || fe(ye, Be)) && De.push(c), fe(ye, Be) && De.push(c)), De.push(Ce), A2 = ye;
                                }
                            }, "children"), le ? le(De) : De;
                        }
                        function Fe(oe) {
                            if (oe.type === "html") return oe.value;
                            if (oe.type === "paragraph" && Array.isArray(oe.children) && oe.children.length === 1 && oe.children[0].type === "esComment") return [
                                "{/* ",
                                oe.children[0].value,
                                " */}"
                            ];
                        }
                        function z(oe) {
                            let H = oe;
                            for(; i(H.children);)H = s(H.children);
                            return H;
                        }
                        function U(oe) {
                            let H;
                            if (oe.type === "html") H = oe.value.match(/^<!--\s*prettier-ignore(?:-(start|end))?\s*-->$/);
                            else {
                                let pe;
                                oe.type === "esComment" ? pe = oe : oe.type === "paragraph" && oe.children.length === 1 && oe.children[0].type === "esComment" && (pe = oe.children[0]), pe && (H = pe.value.match(/^prettier-ignore(?:-(start|end))?$/));
                            }
                            return H ? H[1] || "next" : false;
                        }
                        function Z(oe, H) {
                            let pe = H.parts.length === 0, X = k.includes(oe.type), le = oe.type === "html" && M.includes(H.parentNode.type);
                            return !pe && !X && !le;
                        }
                        function se(oe, H) {
                            var pe, X, le;
                            let Ee = (H.prevNode && H.prevNode.type) === oe.type && L.has(oe.type), De = H.parentNode.type === "listItem" && !H.parentNode.loose, A2 = ((pe = H.prevNode) === null || pe === void 0 ? void 0 : pe.type) === "listItem" && H.prevNode.loose, G = U(H.prevNode) === "next", re = oe.type === "html" && ((X = H.prevNode) === null || X === void 0 ? void 0 : X.type) === "html" && H.prevNode.position.end.line + 1 === oe.position.start.line, ye = oe.type === "html" && H.parentNode.type === "listItem" && ((le = H.prevNode) === null || le === void 0 ? void 0 : le.type) === "paragraph" && H.prevNode.position.end.line + 1 === oe.position.start.line;
                            return A2 || !(Ee || De || G || re || ye);
                        }
                        function fe(oe, H) {
                            let pe = H.prevNode && H.prevNode.type === "list", X = oe.type === "code" && oe.isIndented;
                            return pe && X;
                        }
                        function ge(oe) {
                            let H = ce(oe, [
                                "linkReference",
                                "imageReference"
                            ]);
                            return H && (H.type !== "linkReference" || H.referenceType !== "full");
                        }
                        function he(oe) {
                            let H = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], pe = [
                                " ",
                                ...Array.isArray(H) ? H : [
                                    H
                                ]
                            ];
                            return new RegExp(pe.map((X)=>`\\${X}`).join("|")).test(oe) ? `<${oe}>` : oe;
                        }
                        function we(oe, H) {
                            let pe = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
                            if (!oe) return "";
                            if (pe) return " " + we(oe, H, false);
                            if (oe = oe.replace(/\\(["')])/g, "$1"), oe.includes('"') && oe.includes("'") && !oe.includes(")")) return `(${oe})`;
                            let X = oe.split("'").length - 1, le = oe.split('"').length - 1, Ae = X > le ? '"' : le > X || H.singleQuote ? "'" : '"';
                            return oe = oe.replace(/\\/, "\\\\"), oe = oe.replace(new RegExp(`(${Ae})`, "g"), "\\$1"), `${Ae}${oe}${Ae}`;
                        }
                        function ke(oe, H, pe) {
                            return oe < H ? H : oe > pe ? pe : oe;
                        }
                        function Re(oe) {
                            let H = Number(oe.getName());
                            if (H === 0) return false;
                            let pe = oe.getParentNode().children[H - 1];
                            return U(pe) === "next";
                        }
                        function Ne(oe) {
                            return `[${t1(oe.label)}]`;
                        }
                        function Pe(oe) {
                            return `[^${oe.label}]`;
                        }
                        r.exports = {
                            preprocess: o,
                            print: Q,
                            embed: D,
                            massageAstNode: d,
                            hasPrettierIgnore: Re,
                            insertPragma: T
                        };
                    }
                }), Dg = te({
                    "src/language-markdown/options.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Mt();
                        r.exports = {
                            proseWrap: t1.proseWrap,
                            singleQuote: t1.singleQuote
                        };
                    }
                }), mg = te({
                    "src/language-markdown/parsers.js" () {
                        ne();
                    }
                }), _a = te({
                    "node_modules/linguist-languages/data/Markdown.json" (e, r) {
                        r.exports = {
                            name: "Markdown",
                            type: "prose",
                            color: "#083fa1",
                            aliases: [
                                "pandoc"
                            ],
                            aceMode: "markdown",
                            codemirrorMode: "gfm",
                            codemirrorMimeType: "text/x-gfm",
                            wrap: true,
                            extensions: [
                                ".md",
                                ".livemd",
                                ".markdown",
                                ".mdown",
                                ".mdwn",
                                ".mdx",
                                ".mkd",
                                ".mkdn",
                                ".mkdown",
                                ".ronn",
                                ".scd",
                                ".workbook"
                            ],
                            filenames: [
                                "contents.lr"
                            ],
                            tmScope: "source.gfm",
                            languageId: 222
                        };
                    }
                }), dg = te({
                    "src/language-markdown/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = _t(), s = fg(), a2 = Dg(), n = mg(), u = [
                            t1(_a(), (l)=>({
                                    since: "1.8.0",
                                    parsers: [
                                        "markdown"
                                    ],
                                    vscodeLanguageIds: [
                                        "markdown"
                                    ],
                                    filenames: [
                                        ...l.filenames,
                                        "README"
                                    ],
                                    extensions: l.extensions.filter((p)=>p !== ".mdx")
                                })),
                            t1(_a(), ()=>({
                                    name: "MDX",
                                    since: "1.15.0",
                                    parsers: [
                                        "mdx"
                                    ],
                                    vscodeLanguageIds: [
                                        "mdx"
                                    ],
                                    filenames: [],
                                    extensions: [
                                        ".mdx"
                                    ]
                                }))
                        ], i = {
                            mdast: s
                        };
                        r.exports = {
                            languages: u,
                            options: a2,
                            printers: i,
                            parsers: n
                        };
                    }
                }), gg = te({
                    "src/language-html/clean.js" (e, r) {
                        "use strict";
                        ne();
                        var { isFrontMatterNode: t1 } = Ue(), s = /* @__PURE__ */ new Set([
                            "sourceSpan",
                            "startSourceSpan",
                            "endSourceSpan",
                            "nameSpan",
                            "valueSpan"
                        ]);
                        function a2(n, u) {
                            if (n.type === "text" || n.type === "comment" || t1(n) || n.type === "yaml" || n.type === "toml") return null;
                            n.type === "attribute" && delete u.value, n.type === "docType" && delete u.value;
                        }
                        a2.ignoredProperties = s, r.exports = a2;
                    }
                }), yg = te({
                    "src/language-html/constants.evaluate.js" (e, r) {
                        r.exports = {
                            CSS_DISPLAY_TAGS: {
                                area: "none",
                                base: "none",
                                basefont: "none",
                                datalist: "none",
                                head: "none",
                                link: "none",
                                meta: "none",
                                noembed: "none",
                                noframes: "none",
                                param: "block",
                                rp: "none",
                                script: "block",
                                source: "block",
                                style: "none",
                                template: "inline",
                                track: "block",
                                title: "none",
                                html: "block",
                                body: "block",
                                address: "block",
                                blockquote: "block",
                                center: "block",
                                div: "block",
                                figure: "block",
                                figcaption: "block",
                                footer: "block",
                                form: "block",
                                header: "block",
                                hr: "block",
                                legend: "block",
                                listing: "block",
                                main: "block",
                                p: "block",
                                plaintext: "block",
                                pre: "block",
                                xmp: "block",
                                slot: "contents",
                                ruby: "ruby",
                                rt: "ruby-text",
                                article: "block",
                                aside: "block",
                                h1: "block",
                                h2: "block",
                                h3: "block",
                                h4: "block",
                                h5: "block",
                                h6: "block",
                                hgroup: "block",
                                nav: "block",
                                section: "block",
                                dir: "block",
                                dd: "block",
                                dl: "block",
                                dt: "block",
                                ol: "block",
                                ul: "block",
                                li: "list-item",
                                table: "table",
                                caption: "table-caption",
                                colgroup: "table-column-group",
                                col: "table-column",
                                thead: "table-header-group",
                                tbody: "table-row-group",
                                tfoot: "table-footer-group",
                                tr: "table-row",
                                td: "table-cell",
                                th: "table-cell",
                                fieldset: "block",
                                button: "inline-block",
                                details: "block",
                                summary: "block",
                                dialog: "block",
                                meter: "inline-block",
                                progress: "inline-block",
                                object: "inline-block",
                                video: "inline-block",
                                audio: "inline-block",
                                select: "inline-block",
                                option: "block",
                                optgroup: "block"
                            },
                            CSS_DISPLAY_DEFAULT: "inline",
                            CSS_WHITE_SPACE_TAGS: {
                                listing: "pre",
                                plaintext: "pre",
                                pre: "pre",
                                xmp: "pre",
                                nobr: "nowrap",
                                table: "initial",
                                textarea: "pre-wrap"
                            },
                            CSS_WHITE_SPACE_DEFAULT: "normal"
                        };
                    }
                }), hg = te({
                    "src/language-html/utils/is-unknown-namespace.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s) {
                            return s.type === "element" && !s.hasExplicitNamespace && ![
                                "html",
                                "svg"
                            ].includes(s.namespace);
                        }
                        r.exports = t1;
                    }
                }), Rt = te({
                    "src/language-html/utils/index.js" (e, r) {
                        "use strict";
                        ne();
                        var { inferParserByLanguage: t1, isFrontMatterNode: s } = Ue(), { builders: { line: a2, hardline: n, join: u }, utils: { getDocParts: i, replaceTextEndOfLine: l } } = qe(), { CSS_DISPLAY_TAGS: p, CSS_DISPLAY_DEFAULT: y, CSS_WHITE_SPACE_TAGS: h, CSS_WHITE_SPACE_DEFAULT: g } = yg(), c = hg(), f2 = /* @__PURE__ */ new Set([
                            "	",
                            `
`,
                            "\f",
                            "\r",
                            " "
                        ]), F = (A2)=>A2.replace(/^[\t\n\f\r ]+/, ""), _2 = (A2)=>A2.replace(/[\t\n\f\r ]+$/, ""), w = (A2)=>F(_2(A2)), E = (A2)=>A2.replace(/^[\t\f\r ]*\n/g, ""), N = (A2)=>E(_2(A2)), x = (A2)=>A2.split(/[\t\n\f\r ]+/), I = (A2)=>A2.match(/^[\t\n\f\r ]*/)[0], P = (A2)=>{
                            let [, G, re, ye] = A2.match(RegExp("^([\\t\\n\\f\\r ]*)(.*?)([\\t\\n\\f\\r ]*)$", "s"));
                            return {
                                leadingWhitespace: G,
                                trailingWhitespace: ye,
                                text: re
                            };
                        }, $ = (A2)=>/[\t\n\f\r ]/.test(A2);
                        function D(A2, G) {
                            return !!(A2.type === "ieConditionalComment" && A2.lastChild && !A2.lastChild.isSelfClosing && !A2.lastChild.endSourceSpan || A2.type === "ieConditionalComment" && !A2.complete || se(A2) && A2.children.some((re)=>re.type !== "text" && re.type !== "interpolation") || X(A2, G) && !o(A2) && A2.type !== "interpolation");
                        }
                        function T(A2) {
                            return A2.type === "attribute" || !A2.parent || !A2.prev ? false : m(A2.prev);
                        }
                        function m(A2) {
                            return A2.type === "comment" && A2.value.trim() === "prettier-ignore";
                        }
                        function C(A2) {
                            return A2.type === "text" || A2.type === "comment";
                        }
                        function o(A2) {
                            return A2.type === "element" && (A2.fullName === "script" || A2.fullName === "style" || A2.fullName === "svg:style" || c(A2) && (A2.name === "script" || A2.name === "style"));
                        }
                        function d(A2) {
                            return A2.children && !o(A2);
                        }
                        function v(A2) {
                            return o(A2) || A2.type === "interpolation" || S(A2);
                        }
                        function S(A2) {
                            return we(A2).startsWith("pre");
                        }
                        function b(A2, G) {
                            let re = ye();
                            if (re && !A2.prev && A2.parent && A2.parent.tagDefinition && A2.parent.tagDefinition.ignoreFirstLf) return A2.type === "interpolation";
                            return re;
                            function ye() {
                                return s(A2) ? false : (A2.type === "text" || A2.type === "interpolation") && A2.prev && (A2.prev.type === "text" || A2.prev.type === "interpolation") ? true : !A2.parent || A2.parent.cssDisplay === "none" ? false : se(A2.parent) ? true : !(!A2.prev && (A2.parent.type === "root" || se(A2) && A2.parent || o(A2.parent) || H(A2.parent, G) || !ue(A2.parent.cssDisplay)) || A2.prev && !U(A2.prev.cssDisplay));
                            }
                        }
                        function B(A2, G) {
                            return s(A2) ? false : (A2.type === "text" || A2.type === "interpolation") && A2.next && (A2.next.type === "text" || A2.next.type === "interpolation") ? true : !A2.parent || A2.parent.cssDisplay === "none" ? false : se(A2.parent) ? true : !(!A2.next && (A2.parent.type === "root" || se(A2) && A2.parent || o(A2.parent) || H(A2.parent, G) || !Fe(A2.parent.cssDisplay)) || A2.next && !z(A2.next.cssDisplay));
                        }
                        function k(A2) {
                            return Z(A2.cssDisplay) && !o(A2);
                        }
                        function M(A2) {
                            return s(A2) || A2.next && A2.sourceSpan.end && A2.sourceSpan.end.line + 1 < A2.next.sourceSpan.start.line;
                        }
                        function R(A2) {
                            return q(A2) || A2.type === "element" && A2.children.length > 0 && ([
                                "body",
                                "script",
                                "style"
                            ].includes(A2.name) || A2.children.some((G)=>ee(G))) || A2.firstChild && A2.firstChild === A2.lastChild && A2.firstChild.type !== "text" && V(A2.firstChild) && (!A2.lastChild.isTrailingSpaceSensitive || j(A2.lastChild));
                        }
                        function q(A2) {
                            return A2.type === "element" && A2.children.length > 0 && ([
                                "html",
                                "head",
                                "ul",
                                "ol",
                                "select"
                            ].includes(A2.name) || A2.cssDisplay.startsWith("table") && A2.cssDisplay !== "table-cell");
                        }
                        function J(A2) {
                            return Y(A2) || A2.prev && L(A2.prev) || Q(A2);
                        }
                        function L(A2) {
                            return Y(A2) || A2.type === "element" && A2.fullName === "br" || Q(A2);
                        }
                        function Q(A2) {
                            return V(A2) && j(A2);
                        }
                        function V(A2) {
                            return A2.hasLeadingSpaces && (A2.prev ? A2.prev.sourceSpan.end.line < A2.sourceSpan.start.line : A2.parent.type === "root" || A2.parent.startSourceSpan.end.line < A2.sourceSpan.start.line);
                        }
                        function j(A2) {
                            return A2.hasTrailingSpaces && (A2.next ? A2.next.sourceSpan.start.line > A2.sourceSpan.end.line : A2.parent.type === "root" || A2.parent.endSourceSpan && A2.parent.endSourceSpan.start.line > A2.sourceSpan.end.line);
                        }
                        function Y(A2) {
                            switch(A2.type){
                                case "ieConditionalComment":
                                case "comment":
                                case "directive":
                                    return true;
                                case "element":
                                    return [
                                        "script",
                                        "select"
                                    ].includes(A2.name);
                            }
                            return false;
                        }
                        function ie(A2) {
                            return A2.lastChild ? ie(A2.lastChild) : A2;
                        }
                        function ee(A2) {
                            return A2.children && A2.children.some((G)=>G.type !== "text");
                        }
                        function ce(A2) {
                            let { type: G, lang: re } = A2.attrMap;
                            if (G === "module" || G === "text/javascript" || G === "text/babel" || G === "application/javascript" || re === "jsx") return "babel";
                            if (G === "application/x-typescript" || re === "ts" || re === "tsx") return "typescript";
                            if (G === "text/markdown") return "markdown";
                            if (G === "text/html") return "html";
                            if (G && (G.endsWith("json") || G.endsWith("importmap")) || G === "speculationrules") return "json";
                            if (G === "text/x-handlebars-template") return "glimmer";
                        }
                        function W(A2, G) {
                            let { lang: re } = A2.attrMap;
                            if (!re || re === "postcss" || re === "css") return "css";
                            if (re === "scss") return "scss";
                            if (re === "less") return "less";
                            if (re === "stylus") return t1("stylus", G);
                        }
                        function K(A2, G) {
                            if (A2.name === "script" && !A2.attrMap.src) return !A2.attrMap.lang && !A2.attrMap.type ? "babel" : ce(A2);
                            if (A2.name === "style") return W(A2, G);
                            if (G && X(A2, G)) return ce(A2) || !("src" in A2.attrMap) && t1(A2.attrMap.lang, G);
                        }
                        function de(A2) {
                            return A2 === "block" || A2 === "list-item" || A2.startsWith("table");
                        }
                        function ue(A2) {
                            return !de(A2) && A2 !== "inline-block";
                        }
                        function Fe(A2) {
                            return !de(A2) && A2 !== "inline-block";
                        }
                        function z(A2) {
                            return !de(A2);
                        }
                        function U(A2) {
                            return !de(A2);
                        }
                        function Z(A2) {
                            return !de(A2) && A2 !== "inline-block";
                        }
                        function se(A2) {
                            return we(A2).startsWith("pre");
                        }
                        function fe(A2, G) {
                            let re = 0;
                            for(let ye = A2.stack.length - 1; ye >= 0; ye--){
                                let Ce = A2.stack[ye];
                                Ce && typeof Ce == "object" && !Array.isArray(Ce) && G(Ce) && re++;
                            }
                            return re;
                        }
                        function ge(A2, G) {
                            let re = A2;
                            for(; re;){
                                if (G(re)) return true;
                                re = re.parent;
                            }
                            return false;
                        }
                        function he(A2, G) {
                            if (A2.prev && A2.prev.type === "comment") {
                                let ye = A2.prev.value.match(/^\s*display:\s*([a-z]+)\s*$/);
                                if (ye) return ye[1];
                            }
                            let re = false;
                            if (A2.type === "element" && A2.namespace === "svg") if (ge(A2, (ye)=>ye.fullName === "svg:foreignObject")) re = true;
                            else return A2.name === "svg" ? "inline-block" : "block";
                            switch(G.htmlWhitespaceSensitivity){
                                case "strict":
                                    return "inline";
                                case "ignore":
                                    return "block";
                                default:
                                    return G.parser === "vue" && A2.parent && A2.parent.type === "root" ? "block" : A2.type === "element" && (!A2.namespace || re || c(A2)) && p[A2.name] || y;
                            }
                        }
                        function we(A2) {
                            return A2.type === "element" && (!A2.namespace || c(A2)) && h[A2.name] || g;
                        }
                        function ke(A2) {
                            let G = Number.POSITIVE_INFINITY;
                            for (let re of A2.split(`
`)){
                                if (re.length === 0) continue;
                                if (!f2.has(re[0])) return 0;
                                let ye = I(re).length;
                                re.length !== ye && ye < G && (G = ye);
                            }
                            return G === Number.POSITIVE_INFINITY ? 0 : G;
                        }
                        function Re(A2) {
                            let G = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ke(A2);
                            return G === 0 ? A2 : A2.split(`
`).map((re)=>re.slice(G)).join(`
`);
                        }
                        function Ne(A2, G) {
                            let re = 0;
                            for(let ye = 0; ye < A2.length; ye++)A2[ye] === G && re++;
                            return re;
                        }
                        function Pe(A2) {
                            return A2.replace(/&apos;/g, "'").replace(/&quot;/g, '"');
                        }
                        var oe = /* @__PURE__ */ new Set([
                            "template",
                            "style",
                            "script"
                        ]);
                        function H(A2, G) {
                            return pe(A2, G) && !oe.has(A2.fullName);
                        }
                        function pe(A2, G) {
                            return G.parser === "vue" && A2.type === "element" && A2.parent.type === "root" && A2.fullName.toLowerCase() !== "html";
                        }
                        function X(A2, G) {
                            return pe(A2, G) && (H(A2, G) || A2.attrMap.lang && A2.attrMap.lang !== "html");
                        }
                        function le(A2) {
                            let G = A2.fullName;
                            return G.charAt(0) === "#" || G === "slot-scope" || G === "v-slot" || G.startsWith("v-slot:");
                        }
                        function Ae(A2, G) {
                            let re = A2.parent;
                            if (!pe(re, G)) return false;
                            let ye = re.fullName, Ce = A2.fullName;
                            return ye === "script" && Ce === "setup" || ye === "style" && Ce === "vars";
                        }
                        function Ee(A2) {
                            let G = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : A2.value;
                            return A2.parent.isWhitespaceSensitive ? A2.parent.isIndentationSensitive ? l(G) : l(Re(N(G)), n) : i(u(a2, x(G)));
                        }
                        function De(A2, G) {
                            return pe(A2, G) && A2.name === "script";
                        }
                        r.exports = {
                            htmlTrim: w,
                            htmlTrimPreserveIndentation: N,
                            hasHtmlWhitespace: $,
                            getLeadingAndTrailingHtmlWhitespace: P,
                            canHaveInterpolation: d,
                            countChars: Ne,
                            countParents: fe,
                            dedentString: Re,
                            forceBreakChildren: q,
                            forceBreakContent: R,
                            forceNextEmptyLine: M,
                            getLastDescendant: ie,
                            getNodeCssStyleDisplay: he,
                            getNodeCssStyleWhiteSpace: we,
                            hasPrettierIgnore: T,
                            inferScriptParser: K,
                            isVueCustomBlock: H,
                            isVueNonHtmlBlock: X,
                            isVueScriptTag: De,
                            isVueSlotAttribute: le,
                            isVueSfcBindingsAttribute: Ae,
                            isVueSfcBlock: pe,
                            isDanglingSpaceSensitiveNode: k,
                            isIndentationSensitiveNode: S,
                            isLeadingSpaceSensitiveNode: b,
                            isPreLikeNode: se,
                            isScriptLikeTag: o,
                            isTextLikeNode: C,
                            isTrailingSpaceSensitiveNode: B,
                            isWhitespaceSensitiveNode: v,
                            isUnknownNamespace: c,
                            preferHardlineAsLeadingSpaces: J,
                            preferHardlineAsTrailingSpaces: L,
                            shouldPreserveContent: D,
                            unescapeQuoteEntities: Pe,
                            getTextValueParts: Ee
                        };
                    }
                }), vg = te({
                    "node_modules/angular-html-parser/lib/compiler/src/chars.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        }), e.$EOF = 0, e.$BSPACE = 8, e.$TAB = 9, e.$LF = 10, e.$VTAB = 11, e.$FF = 12, e.$CR = 13, e.$SPACE = 32, e.$BANG = 33, e.$DQ = 34, e.$HASH = 35, e.$$ = 36, e.$PERCENT = 37, e.$AMPERSAND = 38, e.$SQ = 39, e.$LPAREN = 40, e.$RPAREN = 41, e.$STAR = 42, e.$PLUS = 43, e.$COMMA = 44, e.$MINUS = 45, e.$PERIOD = 46, e.$SLASH = 47, e.$COLON = 58, e.$SEMICOLON = 59, e.$LT = 60, e.$EQ = 61, e.$GT = 62, e.$QUESTION = 63, e.$0 = 48, e.$7 = 55, e.$9 = 57, e.$A = 65, e.$E = 69, e.$F = 70, e.$X = 88, e.$Z = 90, e.$LBRACKET = 91, e.$BACKSLASH = 92, e.$RBRACKET = 93, e.$CARET = 94, e.$_ = 95, e.$a = 97, e.$b = 98, e.$e = 101, e.$f = 102, e.$n = 110, e.$r = 114, e.$t = 116, e.$u = 117, e.$v = 118, e.$x = 120, e.$z = 122, e.$LBRACE = 123, e.$BAR = 124, e.$RBRACE = 125, e.$NBSP = 160, e.$PIPE = 124, e.$TILDA = 126, e.$AT = 64, e.$BT = 96;
                        function r(i) {
                            return i >= e.$TAB && i <= e.$SPACE || i == e.$NBSP;
                        }
                        e.isWhitespace = r;
                        function t1(i) {
                            return e.$0 <= i && i <= e.$9;
                        }
                        e.isDigit = t1;
                        function s(i) {
                            return i >= e.$a && i <= e.$z || i >= e.$A && i <= e.$Z;
                        }
                        e.isAsciiLetter = s;
                        function a2(i) {
                            return i >= e.$a && i <= e.$f || i >= e.$A && i <= e.$F || t1(i);
                        }
                        e.isAsciiHexDigit = a2;
                        function n(i) {
                            return i === e.$LF || i === e.$CR;
                        }
                        e.isNewLine = n;
                        function u(i) {
                            return e.$0 <= i && i <= e.$7;
                        }
                        e.isOctalDigit = u;
                    }
                }), Cg = te({
                    "node_modules/angular-html-parser/lib/compiler/src/aot/static_symbol.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = class {
                            assertNoMembers() {
                                if (this.members.length) throw new Error(`Illegal state: symbol without members expected, but got ${JSON.stringify(this)}.`);
                            }
                            constructor(s, a2, n){
                                this.filePath = s, this.name = a2, this.members = n;
                            }
                        };
                        e.StaticSymbol = r;
                        var t1 = class {
                            get(s, a2, n) {
                                n = n || [];
                                let u = n.length ? `.${n.join(".")}` : "", i = `"${s}".${a2}${u}`, l = this.cache.get(i);
                                return l || (l = new r(s, a2, n), this.cache.set(i, l)), l;
                            }
                            constructor(){
                                this.cache = /* @__PURE__ */ new Map();
                            }
                        };
                        e.StaticSymbolCache = t1;
                    }
                }), Eg = te({
                    "node_modules/angular-html-parser/lib/compiler/src/util.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = /-+([a-z0-9])/g;
                        function t1(o) {
                            return o.replace(r, function() {
                                for(var d = arguments.length, v = new Array(d), S = 0; S < d; S++)v[S] = arguments[S];
                                return v[1].toUpperCase();
                            });
                        }
                        e.dashCaseToCamelCase = t1;
                        function s(o, d) {
                            return n(o, ":", d);
                        }
                        e.splitAtColon = s;
                        function a2(o, d) {
                            return n(o, ".", d);
                        }
                        e.splitAtPeriod = a2;
                        function n(o, d, v) {
                            let S = o.indexOf(d);
                            return S == -1 ? v : [
                                o.slice(0, S).trim(),
                                o.slice(S + 1).trim()
                            ];
                        }
                        function u(o, d, v) {
                            return Array.isArray(o) ? d.visitArray(o, v) : E(o) ? d.visitStringMap(o, v) : o == null || typeof o == "string" || typeof o == "number" || typeof o == "boolean" ? d.visitPrimitive(o, v) : d.visitOther(o, v);
                        }
                        e.visitValue = u;
                        function i(o) {
                            return o != null;
                        }
                        e.isDefined = i;
                        function l(o) {
                            return o === void 0 ? null : o;
                        }
                        e.noUndefined = l;
                        var p = class {
                            visitArray(o, d) {
                                return o.map((v)=>u(v, this, d));
                            }
                            visitStringMap(o, d) {
                                let v = {};
                                return Object.keys(o).forEach((S)=>{
                                    v[S] = u(o[S], this, d);
                                }), v;
                            }
                            visitPrimitive(o, d) {
                                return o;
                            }
                            visitOther(o, d) {
                                return o;
                            }
                        };
                        e.ValueTransformer = p, e.SyncAsync = {
                            assertSync: (o)=>{
                                if (P(o)) throw new Error("Illegal state: value cannot be a promise");
                                return o;
                            },
                            then: (o, d)=>P(o) ? o.then(d) : d(o),
                            all: (o)=>o.some(P) ? Promise.all(o) : o
                        };
                        function y(o) {
                            throw new Error(`Internal Error: ${o}`);
                        }
                        e.error = y;
                        function h(o, d) {
                            let v = Error(o);
                            return v[g] = true, d && (v[c] = d), v;
                        }
                        e.syntaxError = h;
                        var g = "ngSyntaxError", c = "ngParseErrors";
                        function f2(o) {
                            return o[g];
                        }
                        e.isSyntaxError = f2;
                        function F(o) {
                            return o[c] || [];
                        }
                        e.getParseErrors = F;
                        function _2(o) {
                            return o.replace(/([.*+?^=!:${}()|[\]\/\\])/g, "\\$1");
                        }
                        e.escapeRegExp = _2;
                        var w = Object.getPrototypeOf({});
                        function E(o) {
                            return typeof o == "object" && o !== null && Object.getPrototypeOf(o) === w;
                        }
                        function N(o) {
                            let d = "";
                            for(let v = 0; v < o.length; v++){
                                let S = o.charCodeAt(v);
                                if (S >= 55296 && S <= 56319 && o.length > v + 1) {
                                    let b = o.charCodeAt(v + 1);
                                    b >= 56320 && b <= 57343 && (v++, S = (S - 55296 << 10) + b - 56320 + 65536);
                                }
                                S <= 127 ? d += String.fromCharCode(S) : S <= 2047 ? d += String.fromCharCode(S >> 6 & 31 | 192, S & 63 | 128) : S <= 65535 ? d += String.fromCharCode(S >> 12 | 224, S >> 6 & 63 | 128, S & 63 | 128) : S <= 2097151 && (d += String.fromCharCode(S >> 18 & 7 | 240, S >> 12 & 63 | 128, S >> 6 & 63 | 128, S & 63 | 128));
                            }
                            return d;
                        }
                        e.utf8Encode = N;
                        function x(o) {
                            if (typeof o == "string") return o;
                            if (o instanceof Array) return "[" + o.map(x).join(", ") + "]";
                            if (o == null) return "" + o;
                            if (o.overriddenName) return `${o.overriddenName}`;
                            if (o.name) return `${o.name}`;
                            if (!o.toString) return "object";
                            let d = o.toString();
                            if (d == null) return "" + d;
                            let v = d.indexOf(`
`);
                            return v === -1 ? d : d.substring(0, v);
                        }
                        e.stringify = x;
                        function I(o) {
                            return typeof o == "function" && o.hasOwnProperty("__forward_ref__") ? o() : o;
                        }
                        e.resolveForwardRef = I;
                        function P(o) {
                            return !!o && typeof o.then == "function";
                        }
                        e.isPromise = P;
                        var $ = class {
                            constructor(o){
                                this.full = o;
                                let d = o.split(".");
                                this.major = d[0], this.minor = d[1], this.patch = d.slice(2).join(".");
                            }
                        };
                        e.Version = $;
                        var D = typeof window < "u" && window, T = typeof self < "u" && typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope && self, m = typeof globalThis < "u" && globalThis, C = m || D || T;
                        e.global = C;
                    }
                }), Fg = te({
                    "node_modules/angular-html-parser/lib/compiler/src/compile_metadata.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = Cg(), t1 = Eg(), s = /^(?:(?:\[([^\]]+)\])|(?:\(([^\)]+)\)))|(\@[-\w]+)$/;
                        function a2(v) {
                            return v.replace(/\W/g, "_");
                        }
                        e.sanitizeIdentifier = a2;
                        var n = 0;
                        function u(v) {
                            if (!v || !v.reference) return null;
                            let S = v.reference;
                            if (S instanceof r.StaticSymbol) return S.name;
                            if (S.__anonymousType) return S.__anonymousType;
                            let b = t1.stringify(S);
                            return b.indexOf("(") >= 0 ? (b = `anonymous_${n++}`, S.__anonymousType = b) : b = a2(b), b;
                        }
                        e.identifierName = u;
                        function i(v) {
                            let S = v.reference;
                            return S instanceof r.StaticSymbol ? S.filePath : `./${t1.stringify(S)}`;
                        }
                        e.identifierModuleUrl = i;
                        function l(v, S) {
                            return `View_${u({
                                reference: v
                            })}_${S}`;
                        }
                        e.viewClassName = l;
                        function p(v) {
                            return `RenderType_${u({
                                reference: v
                            })}`;
                        }
                        e.rendererTypeName = p;
                        function y(v) {
                            return `HostView_${u({
                                reference: v
                            })}`;
                        }
                        e.hostViewClassName = y;
                        function h(v) {
                            return `${u({
                                reference: v
                            })}NgFactory`;
                        }
                        e.componentFactoryName = h;
                        var g;
                        (function(v) {
                            v[v.Pipe = 0] = "Pipe", v[v.Directive = 1] = "Directive", v[v.NgModule = 2] = "NgModule", v[v.Injectable = 3] = "Injectable";
                        })(g = e.CompileSummaryKind || (e.CompileSummaryKind = {}));
                        function c(v) {
                            return v.value != null ? a2(v.value) : u(v.identifier);
                        }
                        e.tokenName = c;
                        function f2(v) {
                            return v.identifier != null ? v.identifier.reference : v.value;
                        }
                        e.tokenReference = f2;
                        var F = class {
                            constructor(){
                                let { moduleUrl: v, styles: S, styleUrls: b } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
                                this.moduleUrl = v || null, this.styles = P(S), this.styleUrls = P(b);
                            }
                        };
                        e.CompileStylesheetMetadata = F;
                        var _2 = class {
                            toSummary() {
                                return {
                                    ngContentSelectors: this.ngContentSelectors,
                                    encapsulation: this.encapsulation,
                                    styles: this.styles,
                                    animations: this.animations
                                };
                            }
                            constructor(v){
                                let { encapsulation: S, template: b, templateUrl: B, htmlAst: k, styles: M, styleUrls: R, externalStylesheets: q, animations: J, ngContentSelectors: L, interpolation: Q, isInline: V, preserveWhitespaces: j } = v;
                                if (this.encapsulation = S, this.template = b, this.templateUrl = B, this.htmlAst = k, this.styles = P(M), this.styleUrls = P(R), this.externalStylesheets = P(q), this.animations = J ? D(J) : [], this.ngContentSelectors = L || [], Q && Q.length != 2) throw new Error("'interpolation' should have a start and an end symbol.");
                                this.interpolation = Q, this.isInline = V, this.preserveWhitespaces = j;
                            }
                        };
                        e.CompileTemplateMetadata = _2;
                        var w = class {
                            static create(v) {
                                let { isHost: S, type: b, isComponent: B, selector: k, exportAs: M, changeDetection: R, inputs: q, outputs: J, host: L, providers: Q, viewProviders: V, queries: j, guards: Y, viewQueries: ie, entryComponents: ee, template: ce, componentViewType: W, rendererType: K, componentFactory: de } = v, ue = {}, Fe = {}, z = {};
                                L != null && Object.keys(L).forEach((se)=>{
                                    let fe = L[se], ge = se.match(s);
                                    ge === null ? z[se] = fe : ge[1] != null ? Fe[ge[1]] = fe : ge[2] != null && (ue[ge[2]] = fe);
                                });
                                let U = {};
                                q != null && q.forEach((se)=>{
                                    let fe = t1.splitAtColon(se, [
                                        se,
                                        se
                                    ]);
                                    U[fe[0]] = fe[1];
                                });
                                let Z = {};
                                return J != null && J.forEach((se)=>{
                                    let fe = t1.splitAtColon(se, [
                                        se,
                                        se
                                    ]);
                                    Z[fe[0]] = fe[1];
                                }), new w({
                                    isHost: S,
                                    type: b,
                                    isComponent: !!B,
                                    selector: k,
                                    exportAs: M,
                                    changeDetection: R,
                                    inputs: U,
                                    outputs: Z,
                                    hostListeners: ue,
                                    hostProperties: Fe,
                                    hostAttributes: z,
                                    providers: Q,
                                    viewProviders: V,
                                    queries: j,
                                    guards: Y,
                                    viewQueries: ie,
                                    entryComponents: ee,
                                    template: ce,
                                    componentViewType: W,
                                    rendererType: K,
                                    componentFactory: de
                                });
                            }
                            toSummary() {
                                return {
                                    summaryKind: g.Directive,
                                    type: this.type,
                                    isComponent: this.isComponent,
                                    selector: this.selector,
                                    exportAs: this.exportAs,
                                    inputs: this.inputs,
                                    outputs: this.outputs,
                                    hostListeners: this.hostListeners,
                                    hostProperties: this.hostProperties,
                                    hostAttributes: this.hostAttributes,
                                    providers: this.providers,
                                    viewProviders: this.viewProviders,
                                    queries: this.queries,
                                    guards: this.guards,
                                    viewQueries: this.viewQueries,
                                    entryComponents: this.entryComponents,
                                    changeDetection: this.changeDetection,
                                    template: this.template && this.template.toSummary(),
                                    componentViewType: this.componentViewType,
                                    rendererType: this.rendererType,
                                    componentFactory: this.componentFactory
                                };
                            }
                            constructor(v){
                                let { isHost: S, type: b, isComponent: B, selector: k, exportAs: M, changeDetection: R, inputs: q, outputs: J, hostListeners: L, hostProperties: Q, hostAttributes: V, providers: j, viewProviders: Y, queries: ie, guards: ee, viewQueries: ce, entryComponents: W, template: K, componentViewType: de, rendererType: ue, componentFactory: Fe } = v;
                                this.isHost = !!S, this.type = b, this.isComponent = B, this.selector = k, this.exportAs = M, this.changeDetection = R, this.inputs = q, this.outputs = J, this.hostListeners = L, this.hostProperties = Q, this.hostAttributes = V, this.providers = P(j), this.viewProviders = P(Y), this.queries = P(ie), this.guards = ee, this.viewQueries = P(ce), this.entryComponents = P(W), this.template = K, this.componentViewType = de, this.rendererType = ue, this.componentFactory = Fe;
                            }
                        };
                        e.CompileDirectiveMetadata = w;
                        var E = class {
                            toSummary() {
                                return {
                                    summaryKind: g.Pipe,
                                    type: this.type,
                                    name: this.name,
                                    pure: this.pure
                                };
                            }
                            constructor(v){
                                let { type: S, name: b, pure: B } = v;
                                this.type = S, this.name = b, this.pure = !!B;
                            }
                        };
                        e.CompilePipeMetadata = E;
                        var N = class {
                        };
                        e.CompileShallowModuleMetadata = N;
                        var x = class {
                            toSummary() {
                                let v = this.transitiveModule;
                                return {
                                    summaryKind: g.NgModule,
                                    type: this.type,
                                    entryComponents: v.entryComponents,
                                    providers: v.providers,
                                    modules: v.modules,
                                    exportedDirectives: v.exportedDirectives,
                                    exportedPipes: v.exportedPipes
                                };
                            }
                            constructor(v){
                                let { type: S, providers: b, declaredDirectives: B, exportedDirectives: k, declaredPipes: M, exportedPipes: R, entryComponents: q, bootstrapComponents: J, importedModules: L, exportedModules: Q, schemas: V, transitiveModule: j, id: Y } = v;
                                this.type = S || null, this.declaredDirectives = P(B), this.exportedDirectives = P(k), this.declaredPipes = P(M), this.exportedPipes = P(R), this.providers = P(b), this.entryComponents = P(q), this.bootstrapComponents = P(J), this.importedModules = P(L), this.exportedModules = P(Q), this.schemas = P(V), this.id = Y || null, this.transitiveModule = j || null;
                            }
                        };
                        e.CompileNgModuleMetadata = x;
                        var I = class {
                            addProvider(v, S) {
                                this.providers.push({
                                    provider: v,
                                    module: S
                                });
                            }
                            addDirective(v) {
                                this.directivesSet.has(v.reference) || (this.directivesSet.add(v.reference), this.directives.push(v));
                            }
                            addExportedDirective(v) {
                                this.exportedDirectivesSet.has(v.reference) || (this.exportedDirectivesSet.add(v.reference), this.exportedDirectives.push(v));
                            }
                            addPipe(v) {
                                this.pipesSet.has(v.reference) || (this.pipesSet.add(v.reference), this.pipes.push(v));
                            }
                            addExportedPipe(v) {
                                this.exportedPipesSet.has(v.reference) || (this.exportedPipesSet.add(v.reference), this.exportedPipes.push(v));
                            }
                            addModule(v) {
                                this.modulesSet.has(v.reference) || (this.modulesSet.add(v.reference), this.modules.push(v));
                            }
                            addEntryComponent(v) {
                                this.entryComponentsSet.has(v.componentType) || (this.entryComponentsSet.add(v.componentType), this.entryComponents.push(v));
                            }
                            constructor(){
                                this.directivesSet = /* @__PURE__ */ new Set(), this.directives = [], this.exportedDirectivesSet = /* @__PURE__ */ new Set(), this.exportedDirectives = [], this.pipesSet = /* @__PURE__ */ new Set(), this.pipes = [], this.exportedPipesSet = /* @__PURE__ */ new Set(), this.exportedPipes = [], this.modulesSet = /* @__PURE__ */ new Set(), this.modules = [], this.entryComponentsSet = /* @__PURE__ */ new Set(), this.entryComponents = [], this.providers = [];
                            }
                        };
                        e.TransitiveCompileNgModuleMetadata = I;
                        function P(v) {
                            return v || [];
                        }
                        var $ = class {
                            constructor(v, S){
                                let { useClass: b, useValue: B, useExisting: k, useFactory: M, deps: R, multi: q } = S;
                                this.token = v, this.useClass = b || null, this.useValue = B, this.useExisting = k, this.useFactory = M || null, this.dependencies = R || null, this.multi = !!q;
                            }
                        };
                        e.ProviderMeta = $;
                        function D(v) {
                            return v.reduce((S, b)=>{
                                let B = Array.isArray(b) ? D(b) : b;
                                return S.concat(B);
                            }, []);
                        }
                        e.flatten = D;
                        function T(v) {
                            return v.replace(/(\w+:\/\/[\w:-]+)?(\/+)?/, "ng:///");
                        }
                        function m(v, S, b) {
                            let B;
                            return b.isInline ? S.type.reference instanceof r.StaticSymbol ? B = `${S.type.reference.filePath}.${S.type.reference.name}.html` : B = `${u(v)}/${u(S.type)}.html` : B = b.templateUrl, S.type.reference instanceof r.StaticSymbol ? B : T(B);
                        }
                        e.templateSourceUrl = m;
                        function C(v, S) {
                            let b = v.moduleUrl.split(/\/\\/g), B = b[b.length - 1];
                            return T(`css/${S}${B}.ngstyle.js`);
                        }
                        e.sharedStylesheetJitUrl = C;
                        function o(v) {
                            return T(`${u(v.type)}/module.ngfactory.js`);
                        }
                        e.ngModuleJitUrl = o;
                        function d(v, S) {
                            return T(`${u(v)}/${u(S.type)}.ngfactory.js`);
                        }
                        e.templateJitUrl = d;
                    }
                }), Ag = te({
                    "node_modules/angular-html-parser/lib/compiler/src/parse_util.js" (e) {
                        "use strict";
                        ne(), Object.defineProperty(e, "__esModule", {
                            value: true
                        });
                        var r = vg(), t1 = Fg(), s = class {
                            toString() {
                                return this.offset != null ? `${this.file.url}@${this.line}:${this.col}` : this.file.url;
                            }
                            moveBy(y) {
                                let h = this.file.content, g = h.length, c = this.offset, f2 = this.line, F = this.col;
                                for(; c > 0 && y < 0;)if (c--, y++, h.charCodeAt(c) == r.$LF) {
                                    f2--;
                                    let w = h.substr(0, c - 1).lastIndexOf(String.fromCharCode(r.$LF));
                                    F = w > 0 ? c - w : c;
                                } else F--;
                                for(; c < g && y > 0;){
                                    let _2 = h.charCodeAt(c);
                                    c++, y--, _2 == r.$LF ? (f2++, F = 0) : F++;
                                }
                                return new s(this.file, c, f2, F);
                            }
                            getContext(y, h) {
                                let g = this.file.content, c = this.offset;
                                if (c != null) {
                                    c > g.length - 1 && (c = g.length - 1);
                                    let f2 = c, F = 0, _2 = 0;
                                    for(; F < y && c > 0 && (c--, F++, !(g[c] == `
` && ++_2 == h)););
                                    for(F = 0, _2 = 0; F < y && f2 < g.length - 1 && (f2++, F++, !(g[f2] == `
` && ++_2 == h)););
                                    return {
                                        before: g.substring(c, this.offset),
                                        after: g.substring(this.offset, f2 + 1)
                                    };
                                }
                                return null;
                            }
                            constructor(y, h, g, c){
                                this.file = y, this.offset = h, this.line = g, this.col = c;
                            }
                        };
                        e.ParseLocation = s;
                        var a2 = class {
                            constructor(y, h){
                                this.content = y, this.url = h;
                            }
                        };
                        e.ParseSourceFile = a2;
                        var n = class {
                            toString() {
                                return this.start.file.content.substring(this.start.offset, this.end.offset);
                            }
                            constructor(y, h){
                                let g = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
                                this.start = y, this.end = h, this.details = g;
                            }
                        };
                        e.ParseSourceSpan = n, e.EMPTY_PARSE_LOCATION = new s(new a2("", ""), 0, 0, 0), e.EMPTY_SOURCE_SPAN = new n(e.EMPTY_PARSE_LOCATION, e.EMPTY_PARSE_LOCATION);
                        var u;
                        (function(y) {
                            y[y.WARNING = 0] = "WARNING", y[y.ERROR = 1] = "ERROR";
                        })(u = e.ParseErrorLevel || (e.ParseErrorLevel = {}));
                        var i = class {
                            contextualMessage() {
                                let y = this.span.start.getContext(100, 3);
                                return y ? `${this.msg} ("${y.before}[${u[this.level]} ->]${y.after}")` : this.msg;
                            }
                            toString() {
                                let y = this.span.details ? `, ${this.span.details}` : "";
                                return `${this.contextualMessage()}: ${this.span.start}${y}`;
                            }
                            constructor(y, h){
                                let g = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : u.ERROR;
                                this.span = y, this.msg = h, this.level = g;
                            }
                        };
                        e.ParseError = i;
                        function l(y, h) {
                            let g = t1.identifierModuleUrl(h), c = g != null ? `in ${y} ${t1.identifierName(h)} in ${g}` : `in ${y} ${t1.identifierName(h)}`, f2 = new a2("", c);
                            return new n(new s(f2, -1, -1, -1), new s(f2, -1, -1, -1));
                        }
                        e.typeSourceSpan = l;
                        function p(y, h, g) {
                            let c = `in ${y} ${h} in ${g}`, f2 = new a2("", c);
                            return new n(new s(f2, -1, -1, -1), new s(f2, -1, -1, -1));
                        }
                        e.r3JitTypeSourceSpan = p;
                    }
                }), Sg = te({
                    "src/language-html/print-preprocess.js" (e, r) {
                        "use strict";
                        ne();
                        var { ParseSourceSpan: t1 } = Ag(), { htmlTrim: s, getLeadingAndTrailingHtmlWhitespace: a2, hasHtmlWhitespace: n, canHaveInterpolation: u, getNodeCssStyleDisplay: i, isDanglingSpaceSensitiveNode: l, isIndentationSensitiveNode: p, isLeadingSpaceSensitiveNode: y, isTrailingSpaceSensitiveNode: h, isWhitespaceSensitiveNode: g, isVueScriptTag: c } = Rt(), f2 = [
                            _2,
                            w,
                            N,
                            I,
                            P,
                            T,
                            $,
                            D,
                            m,
                            x,
                            C
                        ];
                        function F(o, d) {
                            for (let v of f2)v(o, d);
                            return o;
                        }
                        function _2(o) {
                            o.walk((d)=>{
                                if (d.type === "element" && d.tagDefinition.ignoreFirstLf && d.children.length > 0 && d.children[0].type === "text" && d.children[0].value[0] === `
`) {
                                    let v = d.children[0];
                                    v.value.length === 1 ? d.removeChild(v) : v.value = v.value.slice(1);
                                }
                            });
                        }
                        function w(o) {
                            let d = (v)=>v.type === "element" && v.prev && v.prev.type === "ieConditionalStartComment" && v.prev.sourceSpan.end.offset === v.startSourceSpan.start.offset && v.firstChild && v.firstChild.type === "ieConditionalEndComment" && v.firstChild.sourceSpan.start.offset === v.startSourceSpan.end.offset;
                            o.walk((v)=>{
                                if (v.children) for(let S = 0; S < v.children.length; S++){
                                    let b = v.children[S];
                                    if (!d(b)) continue;
                                    let B = b.prev, k = b.firstChild;
                                    v.removeChild(B), S--;
                                    let M = new t1(B.sourceSpan.start, k.sourceSpan.end), R = new t1(M.start, b.sourceSpan.end);
                                    b.condition = B.condition, b.sourceSpan = R, b.startSourceSpan = M, b.removeChild(k);
                                }
                            });
                        }
                        function E(o, d, v) {
                            o.walk((S)=>{
                                if (S.children) for(let b = 0; b < S.children.length; b++){
                                    let B = S.children[b];
                                    if (B.type !== "text" && !d(B)) continue;
                                    B.type !== "text" && (B.type = "text", B.value = v(B));
                                    let k = B.prev;
                                    !k || k.type !== "text" || (k.value += B.value, k.sourceSpan = new t1(k.sourceSpan.start, B.sourceSpan.end), S.removeChild(B), b--);
                                }
                            });
                        }
                        function N(o) {
                            return E(o, (d)=>d.type === "cdata", (d)=>`<![CDATA[${d.value}]]>`);
                        }
                        function x(o) {
                            let d = (v)=>v.type === "element" && v.attrs.length === 0 && v.children.length === 1 && v.firstChild.type === "text" && !n(v.children[0].value) && !v.firstChild.hasLeadingSpaces && !v.firstChild.hasTrailingSpaces && v.isLeadingSpaceSensitive && !v.hasLeadingSpaces && v.isTrailingSpaceSensitive && !v.hasTrailingSpaces && v.prev && v.prev.type === "text" && v.next && v.next.type === "text";
                            o.walk((v)=>{
                                if (v.children) for(let S = 0; S < v.children.length; S++){
                                    let b = v.children[S];
                                    if (!d(b)) continue;
                                    let B = b.prev, k = b.next;
                                    B.value += `<${b.rawName}>` + b.firstChild.value + `</${b.rawName}>` + k.value, B.sourceSpan = new t1(B.sourceSpan.start, k.sourceSpan.end), B.isTrailingSpaceSensitive = k.isTrailingSpaceSensitive, B.hasTrailingSpaces = k.hasTrailingSpaces, v.removeChild(b), S--, v.removeChild(k);
                                }
                            });
                        }
                        function I(o, d) {
                            if (d.parser === "html") return;
                            let v = RegExp("{{(.+?)}}", "s");
                            o.walk((S)=>{
                                if (u(S)) for (let b of S.children){
                                    if (b.type !== "text") continue;
                                    let B = b.sourceSpan.start, k = null, M = b.value.split(v);
                                    for(let R = 0; R < M.length; R++, B = k){
                                        let q = M[R];
                                        if (R % 2 === 0) {
                                            k = B.moveBy(q.length), q.length > 0 && S.insertChildBefore(b, {
                                                type: "text",
                                                value: q,
                                                sourceSpan: new t1(B, k)
                                            });
                                            continue;
                                        }
                                        k = B.moveBy(q.length + 4), S.insertChildBefore(b, {
                                            type: "interpolation",
                                            sourceSpan: new t1(B, k),
                                            children: q.length === 0 ? [] : [
                                                {
                                                    type: "text",
                                                    value: q,
                                                    sourceSpan: new t1(B.moveBy(2), k.moveBy(-2))
                                                }
                                            ]
                                        });
                                    }
                                    S.removeChild(b);
                                }
                            });
                        }
                        function P(o) {
                            o.walk((d)=>{
                                if (!d.children) return;
                                if (d.children.length === 0 || d.children.length === 1 && d.children[0].type === "text" && s(d.children[0].value).length === 0) {
                                    d.hasDanglingSpaces = d.children.length > 0, d.children = [];
                                    return;
                                }
                                let v = g(d), S = p(d);
                                if (!v) for(let b = 0; b < d.children.length; b++){
                                    let B = d.children[b];
                                    if (B.type !== "text") continue;
                                    let { leadingWhitespace: k, text: M, trailingWhitespace: R } = a2(B.value), q = B.prev, J = B.next;
                                    M ? (B.value = M, B.sourceSpan = new t1(B.sourceSpan.start.moveBy(k.length), B.sourceSpan.end.moveBy(-R.length)), k && (q && (q.hasTrailingSpaces = true), B.hasLeadingSpaces = true), R && (B.hasTrailingSpaces = true, J && (J.hasLeadingSpaces = true))) : (d.removeChild(B), b--, (k || R) && (q && (q.hasTrailingSpaces = true), J && (J.hasLeadingSpaces = true)));
                                }
                                d.isWhitespaceSensitive = v, d.isIndentationSensitive = S;
                            });
                        }
                        function $(o) {
                            o.walk((d)=>{
                                d.isSelfClosing = !d.children || d.type === "element" && (d.tagDefinition.isVoid || d.startSourceSpan === d.endSourceSpan);
                            });
                        }
                        function D(o, d) {
                            o.walk((v)=>{
                                v.type === "element" && (v.hasHtmComponentClosingTag = v.endSourceSpan && /^<\s*\/\s*\/\s*>$/.test(d.originalText.slice(v.endSourceSpan.start.offset, v.endSourceSpan.end.offset)));
                            });
                        }
                        function T(o, d) {
                            o.walk((v)=>{
                                v.cssDisplay = i(v, d);
                            });
                        }
                        function m(o, d) {
                            o.walk((v)=>{
                                let { children: S } = v;
                                if (S) {
                                    if (S.length === 0) {
                                        v.isDanglingSpaceSensitive = l(v);
                                        return;
                                    }
                                    for (let b of S)b.isLeadingSpaceSensitive = y(b, d), b.isTrailingSpaceSensitive = h(b, d);
                                    for(let b = 0; b < S.length; b++){
                                        let B = S[b];
                                        B.isLeadingSpaceSensitive = (b === 0 || B.prev.isTrailingSpaceSensitive) && B.isLeadingSpaceSensitive, B.isTrailingSpaceSensitive = (b === S.length - 1 || B.next.isLeadingSpaceSensitive) && B.isTrailingSpaceSensitive;
                                    }
                                }
                            });
                        }
                        function C(o, d) {
                            if (d.parser === "vue") {
                                let v = o.children.find((b)=>c(b, d));
                                if (!v) return;
                                let { lang: S } = v.attrMap;
                                (S === "ts" || S === "typescript") && (d.__should_parse_vue_template_with_ts = true);
                            }
                        }
                        r.exports = F;
                    }
                }), xg = te({
                    "src/language-html/pragma.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(a2) {
                            return /^\s*<!--\s*@(?:format|prettier)\s*-->/.test(a2);
                        }
                        function s(a2) {
                            return `<!-- @format -->

` + a2.replace(/^\s*\n/, "");
                        }
                        r.exports = {
                            hasPragma: t1,
                            insertPragma: s
                        };
                    }
                }), au = te({
                    "src/language-html/loc.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(a2) {
                            return a2.sourceSpan.start.offset;
                        }
                        function s(a2) {
                            return a2.sourceSpan.end.offset;
                        }
                        r.exports = {
                            locStart: t1,
                            locEnd: s
                        };
                    }
                }), ur = te({
                    "src/language-html/print/tag.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Zt(), { isNonEmptyArray: s } = Ue(), { builders: { indent: a2, join: n, line: u, softline: i, hardline: l }, utils: { replaceTextEndOfLine: p } } = qe(), { locStart: y, locEnd: h } = au(), { isTextLikeNode: g, getLastDescendant: c, isPreLikeNode: f2, hasPrettierIgnore: F, shouldPreserveContent: _2, isVueSfcBlock: w } = Rt();
                        function E(L, Q) {
                            return [
                                L.isSelfClosing ? "" : N(L, Q),
                                x(L, Q)
                            ];
                        }
                        function N(L, Q) {
                            return L.lastChild && o(L.lastChild) ? "" : [
                                I(L, Q),
                                $(L, Q)
                            ];
                        }
                        function x(L, Q) {
                            return (L.next ? m(L.next) : C(L.parent)) ? "" : [
                                D(L, Q),
                                P(L, Q)
                            ];
                        }
                        function I(L, Q) {
                            return C(L) ? D(L.lastChild, Q) : "";
                        }
                        function P(L, Q) {
                            return o(L) ? $(L.parent, Q) : d(L) ? q(L.next) : "";
                        }
                        function $(L, Q) {
                            if (t1(!L.isSelfClosing), T(L, Q)) return "";
                            switch(L.type){
                                case "ieConditionalComment":
                                    return "<!";
                                case "element":
                                    if (L.hasHtmComponentClosingTag) return "<//";
                                default:
                                    return `</${L.rawName}`;
                            }
                        }
                        function D(L, Q) {
                            if (T(L, Q)) return "";
                            switch(L.type){
                                case "ieConditionalComment":
                                case "ieConditionalEndComment":
                                    return "[endif]-->";
                                case "ieConditionalStartComment":
                                    return "]><!-->";
                                case "interpolation":
                                    return "}}";
                                case "element":
                                    if (L.isSelfClosing) return "/>";
                                default:
                                    return ">";
                            }
                        }
                        function T(L, Q) {
                            return !L.isSelfClosing && !L.endSourceSpan && (F(L) || _2(L.parent, Q));
                        }
                        function m(L) {
                            return L.prev && L.prev.type !== "docType" && !g(L.prev) && L.isLeadingSpaceSensitive && !L.hasLeadingSpaces;
                        }
                        function C(L) {
                            return L.lastChild && L.lastChild.isTrailingSpaceSensitive && !L.lastChild.hasTrailingSpaces && !g(c(L.lastChild)) && !f2(L);
                        }
                        function o(L) {
                            return !L.next && !L.hasTrailingSpaces && L.isTrailingSpaceSensitive && g(c(L));
                        }
                        function d(L) {
                            return L.next && !g(L.next) && g(L) && L.isTrailingSpaceSensitive && !L.hasTrailingSpaces;
                        }
                        function v(L) {
                            let Q = L.trim().match(RegExp("^prettier-ignore-attribute(?:\\s+(.+))?$", "s"));
                            return Q ? Q[1] ? Q[1].split(/\s+/) : true : false;
                        }
                        function S(L) {
                            return !L.prev && L.isLeadingSpaceSensitive && !L.hasLeadingSpaces;
                        }
                        function b(L, Q, V) {
                            let j = L.getValue();
                            if (!s(j.attrs)) return j.isSelfClosing ? " " : "";
                            let Y = j.prev && j.prev.type === "comment" && v(j.prev.value), ie = typeof Y == "boolean" ? ()=>Y : Array.isArray(Y) ? (ue)=>Y.includes(ue.rawName) : ()=>false, ee = L.map((ue)=>{
                                let Fe = ue.getValue();
                                return ie(Fe) ? p(Q.originalText.slice(y(Fe), h(Fe))) : V();
                            }, "attrs"), ce = j.type === "element" && j.fullName === "script" && j.attrs.length === 1 && j.attrs[0].fullName === "src" && j.children.length === 0, K = Q.singleAttributePerLine && j.attrs.length > 1 && !w(j, Q) ? l : u, de = [
                                a2([
                                    ce ? " " : u,
                                    n(K, ee)
                                ])
                            ];
                            return j.firstChild && S(j.firstChild) || j.isSelfClosing && C(j.parent) || ce ? de.push(j.isSelfClosing ? " " : "") : de.push(Q.bracketSameLine ? j.isSelfClosing ? " " : "" : j.isSelfClosing ? u : i), de;
                        }
                        function B(L) {
                            return L.firstChild && S(L.firstChild) ? "" : J(L);
                        }
                        function k(L, Q, V) {
                            let j = L.getValue();
                            return [
                                M(j, Q),
                                b(L, Q, V),
                                j.isSelfClosing ? "" : B(j)
                            ];
                        }
                        function M(L, Q) {
                            return L.prev && d(L.prev) ? "" : [
                                R(L, Q),
                                q(L)
                            ];
                        }
                        function R(L, Q) {
                            return S(L) ? J(L.parent) : m(L) ? D(L.prev, Q) : "";
                        }
                        function q(L) {
                            switch(L.type){
                                case "ieConditionalComment":
                                case "ieConditionalStartComment":
                                    return `<!--[if ${L.condition}`;
                                case "ieConditionalEndComment":
                                    return "<!--<!";
                                case "interpolation":
                                    return "{{";
                                case "docType":
                                    return "<!DOCTYPE";
                                case "element":
                                    if (L.condition) return `<!--[if ${L.condition}]><!--><${L.rawName}`;
                                default:
                                    return `<${L.rawName}`;
                            }
                        }
                        function J(L) {
                            switch(t1(!L.isSelfClosing), L.type){
                                case "ieConditionalComment":
                                    return "]>";
                                case "element":
                                    if (L.condition) return "><!--<![endif]-->";
                                default:
                                    return ">";
                            }
                        }
                        r.exports = {
                            printClosingTag: E,
                            printClosingTagStart: N,
                            printClosingTagStartMarker: $,
                            printClosingTagEndMarker: D,
                            printClosingTagSuffix: P,
                            printClosingTagEnd: x,
                            needsToBorrowLastChildClosingTagEndMarker: C,
                            needsToBorrowParentClosingTagStartMarker: o,
                            needsToBorrowPrevClosingTagEndMarker: m,
                            printOpeningTag: k,
                            printOpeningTagStart: M,
                            printOpeningTagPrefix: R,
                            printOpeningTagStartMarker: q,
                            printOpeningTagEndMarker: J,
                            needsToBorrowNextOpeningTagStartMarker: d,
                            needsToBorrowParentOpeningTagEndMarker: S
                        };
                    }
                }), bg = te({
                    "node_modules/parse-srcset/src/parse-srcset.js" (e, r) {
                        ne(), function(t1, s) {
                            typeof define == "function" && __webpack_require__.amdO ? define([], s) : typeof r == "object" && r.exports ? r.exports = s() : t1.parseSrcset = s();
                        }(e, function() {
                            return function(t1, s) {
                                var a2 = s && s.logger || console;
                                function n($) {
                                    return $ === " " || $ === "	" || $ === `
` || $ === "\f" || $ === "\r";
                                }
                                function u($) {
                                    var D, T = $.exec(t1.substring(N));
                                    if (T) return D = T[0], N += D.length, D;
                                }
                                for(var i = t1.length, l = /^[ \t\n\r\u000c]+/, p = /^[, \t\n\r\u000c]+/, y = /^[^ \t\n\r\u000c]+/, h = /[,]+$/, g = /^\d+$/, c = /^-?(?:[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/, f2, F, _2, w, E, N = 0, x = [];;){
                                    if (u(p), N >= i) return x;
                                    f2 = u(y), F = [], f2.slice(-1) === "," ? (f2 = f2.replace(h, ""), P()) : I();
                                }
                                function I() {
                                    for(u(l), _2 = "", w = "in descriptor";;){
                                        if (E = t1.charAt(N), w === "in descriptor") if (n(E)) _2 && (F.push(_2), _2 = "", w = "after descriptor");
                                        else if (E === ",") {
                                            N += 1, _2 && F.push(_2), P();
                                            return;
                                        } else if (E === "(") _2 = _2 + E, w = "in parens";
                                        else if (E === "") {
                                            _2 && F.push(_2), P();
                                            return;
                                        } else _2 = _2 + E;
                                        else if (w === "in parens") if (E === ")") _2 = _2 + E, w = "in descriptor";
                                        else if (E === "") {
                                            F.push(_2), P();
                                            return;
                                        } else _2 = _2 + E;
                                        else if (w === "after descriptor" && !n(E)) if (E === "") {
                                            P();
                                            return;
                                        } else w = "in descriptor", N -= 1;
                                        N += 1;
                                    }
                                }
                                function P() {
                                    var $ = false, D, T, m, C, o = {}, d, v, S, b, B;
                                    for(C = 0; C < F.length; C++)d = F[C], v = d[d.length - 1], S = d.substring(0, d.length - 1), b = parseInt(S, 10), B = parseFloat(S), g.test(S) && v === "w" ? ((D || T) && ($ = true), b === 0 ? $ = true : D = b) : c.test(S) && v === "x" ? ((D || T || m) && ($ = true), B < 0 ? $ = true : T = B) : g.test(S) && v === "h" ? ((m || T) && ($ = true), b === 0 ? $ = true : m = b) : $ = true;
                                    $ ? a2 && a2.error && a2.error("Invalid srcset descriptor found in '" + t1 + "' at '" + d + "'.") : (o.url = f2, D && (o.w = D), T && (o.d = T), m && (o.h = m), x.push(o));
                                }
                            };
                        });
                    }
                }), Tg = te({
                    "src/language-html/syntax-attribute.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = bg(), { builders: { ifBreak: s, join: a2, line: n } } = qe();
                        function u(l) {
                            let p = t1(l, {
                                logger: {
                                    error (I) {
                                        throw new Error(I);
                                    }
                                }
                            }), y = p.some((I)=>{
                                let { w: P } = I;
                                return P;
                            }), h = p.some((I)=>{
                                let { h: P } = I;
                                return P;
                            }), g = p.some((I)=>{
                                let { d: P } = I;
                                return P;
                            });
                            if (y + h + g > 1) throw new Error("Mixed descriptor in srcset is not supported");
                            let c = y ? "w" : h ? "h" : "d", f2 = y ? "w" : h ? "h" : "x", F = (I)=>Math.max(...I), _2 = p.map((I)=>I.url), w = F(_2.map((I)=>I.length)), E = p.map((I)=>I[c]).map((I)=>I ? I.toString() : ""), N = E.map((I)=>{
                                let P = I.indexOf(".");
                                return P === -1 ? I.length : P;
                            }), x = F(N);
                            return a2([
                                ",",
                                n
                            ], _2.map((I, P)=>{
                                let $ = [
                                    I
                                ], D = E[P];
                                if (D) {
                                    let T = w - I.length + 1, m = x - N[P], C = " ".repeat(T + m);
                                    $.push(s(C, " "), D + f2);
                                }
                                return $;
                            }));
                        }
                        function i(l) {
                            return l.trim().split(/\s+/).join(" ");
                        }
                        r.exports = {
                            printImgSrcset: u,
                            printClassNames: i
                        };
                    }
                }), Bg = te({
                    "src/language-html/syntax-vue.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { group: t1 } } = qe();
                        function s(i, l) {
                            let { left: p, operator: y, right: h } = a2(i);
                            return [
                                t1(l(`function _(${p}) {}`, {
                                    parser: "babel",
                                    __isVueForBindingLeft: true
                                })),
                                " ",
                                y,
                                " ",
                                l(h, {
                                    parser: "__js_expression"
                                }, {
                                    stripTrailingHardline: true
                                })
                            ];
                        }
                        function a2(i) {
                            let l = RegExp("(.*?)\\s+(in|of)\\s+(.*)", "s"), p = /,([^,\]}]*)(?:,([^,\]}]*))?$/, y = /^\(|\)$/g, h = i.match(l);
                            if (!h) return;
                            let g = {};
                            if (g.for = h[3].trim(), !g.for) return;
                            let c = h[1].trim().replace(y, ""), f2 = c.match(p);
                            f2 ? (g.alias = c.replace(p, ""), g.iterator1 = f2[1].trim(), f2[2] && (g.iterator2 = f2[2].trim())) : g.alias = c;
                            let F = [
                                g.alias,
                                g.iterator1,
                                g.iterator2
                            ];
                            if (!F.some((_2, w)=>!_2 && (w === 0 || F.slice(w + 1).some(Boolean)))) return {
                                left: F.filter(Boolean).join(","),
                                operator: h[2],
                                right: g.for
                            };
                        }
                        function n(i, l) {
                            return l(`function _(${i}) {}`, {
                                parser: "babel",
                                __isVueBindings: true
                            });
                        }
                        function u(i) {
                            let l = /^(?:[\w$]+|\([^)]*\))\s*=>|^function\s*\(/, p = /^[$A-Z_a-z][\w$]*(?:\.[$A-Z_a-z][\w$]*|\['[^']*']|\["[^"]*"]|\[\d+]|\[[$A-Z_a-z][\w$]*])*$/, y = i.trim();
                            return l.test(y) || p.test(y);
                        }
                        r.exports = {
                            isVueEventBindingExpression: u,
                            printVueFor: s,
                            printVueBindings: n
                        };
                    }
                }), Lo = te({
                    "src/language-html/get-node-content.js" (e, r) {
                        "use strict";
                        ne();
                        var { needsToBorrowParentClosingTagStartMarker: t1, printClosingTagStartMarker: s, needsToBorrowLastChildClosingTagEndMarker: a2, printClosingTagEndMarker: n, needsToBorrowParentOpeningTagEndMarker: u, printOpeningTagEndMarker: i } = ur();
                        function l(p, y) {
                            let h = p.startSourceSpan.end.offset;
                            p.firstChild && u(p.firstChild) && (h -= i(p).length);
                            let g = p.endSourceSpan.start.offset;
                            return p.lastChild && t1(p.lastChild) ? g += s(p, y).length : a2(p) && (g -= n(p.lastChild, y).length), y.originalText.slice(h, g);
                        }
                        r.exports = l;
                    }
                }), Ng = te({
                    "src/language-html/embed.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { breakParent: t1, group: s, hardline: a2, indent: n, line: u, fill: i, softline: l }, utils: { mapDoc: p, replaceTextEndOfLine: y } } = qe(), h = su(), { printClosingTag: g, printClosingTagSuffix: c, needsToBorrowPrevClosingTagEndMarker: f2, printOpeningTagPrefix: F, printOpeningTag: _2 } = ur(), { printImgSrcset: w, printClassNames: E } = Tg(), { printVueFor: N, printVueBindings: x, isVueEventBindingExpression: I } = Bg(), { isScriptLikeTag: P, isVueNonHtmlBlock: $, inferScriptParser: D, htmlTrimPreserveIndentation: T, dedentString: m, unescapeQuoteEntities: C, isVueSlotAttribute: o, isVueSfcBindingsAttribute: d, getTextValueParts: v } = Rt(), S = Lo();
                        function b(k, M, R) {
                            let q = (ee)=>new RegExp(ee.join("|")).test(k.fullName), J = ()=>C(k.value), L = false, Q = (ee, ce)=>{
                                let W = ee.type === "NGRoot" ? ee.node.type === "NGMicrosyntax" && ee.node.body.length === 1 && ee.node.body[0].type === "NGMicrosyntaxExpression" ? ee.node.body[0].expression : ee.node : ee.type === "JsExpressionRoot" ? ee.node : ee;
                                W && (W.type === "ObjectExpression" || W.type === "ArrayExpression" || ce.parser === "__vue_expression" && (W.type === "TemplateLiteral" || W.type === "StringLiteral")) && (L = true);
                            }, V = (ee)=>s(ee), j = function(ee) {
                                let ce = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
                                return s([
                                    n([
                                        l,
                                        ee
                                    ]),
                                    ce ? l : ""
                                ]);
                            }, Y = (ee)=>L ? V(ee) : j(ee), ie = (ee, ce)=>M(ee, Object.assign({
                                    __onHtmlBindingRoot: Q,
                                    __embeddedInHtml: true
                                }, ce));
                            if (k.fullName === "srcset" && (k.parent.fullName === "img" || k.parent.fullName === "source")) return j(w(J()));
                            if (k.fullName === "class" && !R.parentParser) {
                                let ee = J();
                                if (!ee.includes("{{")) return E(ee);
                            }
                            if (k.fullName === "style" && !R.parentParser) {
                                let ee = J();
                                if (!ee.includes("{{")) return j(ie(ee, {
                                    parser: "css",
                                    __isHTMLStyleAttribute: true
                                }));
                            }
                            if (R.parser === "vue") {
                                if (k.fullName === "v-for") return N(J(), ie);
                                if (o(k) || d(k, R)) return x(J(), ie);
                                let ee = [
                                    "^@",
                                    "^v-on:"
                                ], ce = [
                                    "^:",
                                    "^v-bind:"
                                ], W = [
                                    "^v-"
                                ];
                                if (q(ee)) {
                                    let K = J(), de = I(K) ? "__js_expression" : R.__should_parse_vue_template_with_ts ? "__vue_ts_event_binding" : "__vue_event_binding";
                                    return Y(ie(K, {
                                        parser: de
                                    }));
                                }
                                if (q(ce)) return Y(ie(J(), {
                                    parser: "__vue_expression"
                                }));
                                if (q(W)) return Y(ie(J(), {
                                    parser: "__js_expression"
                                }));
                            }
                            if (R.parser === "angular") {
                                let ee = (z, U)=>ie(z, Object.assign(Object.assign({}, U), {}, {
                                        trailingComma: "none"
                                    })), ce = [
                                    "^\\*"
                                ], W = [
                                    "^\\(.+\\)$",
                                    "^on-"
                                ], K = [
                                    "^\\[.+\\]$",
                                    "^bind(on)?-",
                                    "^ng-(if|show|hide|class|style)$"
                                ], de = [
                                    "^i18n(-.+)?$"
                                ];
                                if (q(W)) return Y(ee(J(), {
                                    parser: "__ng_action"
                                }));
                                if (q(K)) return Y(ee(J(), {
                                    parser: "__ng_binding"
                                }));
                                if (q(de)) {
                                    let z = J().trim();
                                    return j(i(v(k, z)), !z.includes("@@"));
                                }
                                if (q(ce)) return Y(ee(J(), {
                                    parser: "__ng_directive"
                                }));
                                let ue = RegExp("{{(.+?)}}", "s"), Fe = J();
                                if (ue.test(Fe)) {
                                    let z = [];
                                    for (let [U, Z] of Fe.split(ue).entries())if (U % 2 === 0) z.push(y(Z));
                                    else try {
                                        z.push(s([
                                            "{{",
                                            n([
                                                u,
                                                ee(Z, {
                                                    parser: "__ng_interpolation",
                                                    __isInHtmlInterpolation: true
                                                })
                                            ]),
                                            u,
                                            "}}"
                                        ]));
                                    } catch  {
                                        z.push("{{", y(Z), "}}");
                                    }
                                    return s(z);
                                }
                            }
                            return null;
                        }
                        function B(k, M, R, q) {
                            let J = k.getValue();
                            switch(J.type){
                                case "element":
                                    {
                                        if (P(J) || J.type === "interpolation") return;
                                        if (!J.isSelfClosing && $(J, q)) {
                                            let L = D(J, q);
                                            if (!L) return;
                                            let Q = S(J, q), V = /^\s*$/.test(Q), j = "";
                                            return V || (j = R(T(Q), {
                                                parser: L,
                                                __embeddedInHtml: true
                                            }, {
                                                stripTrailingHardline: true
                                            }), V = j === ""), [
                                                F(J, q),
                                                s(_2(k, q, M)),
                                                V ? "" : a2,
                                                j,
                                                V ? "" : a2,
                                                g(J, q),
                                                c(J, q)
                                            ];
                                        }
                                        break;
                                    }
                                case "text":
                                    {
                                        if (P(J.parent)) {
                                            let L = D(J.parent, q);
                                            if (L) {
                                                let Q = L === "markdown" ? m(J.value.replace(/^[^\S\n]*\n/, "")) : J.value, V = {
                                                    parser: L,
                                                    __embeddedInHtml: true
                                                };
                                                if (q.parser === "html" && L === "babel") {
                                                    let j = "script", { attrMap: Y } = J.parent;
                                                    Y && (Y.type === "module" || Y.type === "text/babel" && Y["data-type"] === "module") && (j = "module"), V.__babelSourceType = j;
                                                }
                                                return [
                                                    t1,
                                                    F(J, q),
                                                    R(Q, V, {
                                                        stripTrailingHardline: true
                                                    }),
                                                    c(J, q)
                                                ];
                                            }
                                        } else if (J.parent.type === "interpolation") {
                                            let L = {
                                                __isInHtmlInterpolation: true,
                                                __embeddedInHtml: true
                                            };
                                            return q.parser === "angular" ? (L.parser = "__ng_interpolation", L.trailingComma = "none") : q.parser === "vue" ? L.parser = q.__should_parse_vue_template_with_ts ? "__vue_ts_expression" : "__vue_expression" : L.parser = "__js_expression", [
                                                n([
                                                    u,
                                                    R(J.value, L, {
                                                        stripTrailingHardline: true
                                                    })
                                                ]),
                                                J.parent.next && f2(J.parent.next) ? " " : u
                                            ];
                                        }
                                        break;
                                    }
                                case "attribute":
                                    {
                                        if (!J.value) break;
                                        if (/^PRETTIER_HTML_PLACEHOLDER_\d+_\d+_IN_JS$/.test(q.originalText.slice(J.valueSpan.start.offset, J.valueSpan.end.offset))) return [
                                            J.rawName,
                                            "=",
                                            J.value
                                        ];
                                        if (q.parser === "lwc" && RegExp("^{.*}$", "s").test(q.originalText.slice(J.valueSpan.start.offset, J.valueSpan.end.offset))) return [
                                            J.rawName,
                                            "=",
                                            J.value
                                        ];
                                        let L = b(J, (Q, V)=>R(Q, Object.assign({
                                                __isInHtmlAttribute: true,
                                                __embeddedInHtml: true
                                            }, V), {
                                                stripTrailingHardline: true
                                            }), q);
                                        if (L) return [
                                            J.rawName,
                                            '="',
                                            s(p(L, (Q)=>typeof Q == "string" ? Q.replace(/"/g, "&quot;") : Q)),
                                            '"'
                                        ];
                                        break;
                                    }
                                case "front-matter":
                                    return h(J, R);
                            }
                        }
                        r.exports = B;
                    }
                }), Oo = te({
                    "src/language-html/print/children.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { breakParent: t1, group: s, ifBreak: a2, line: n, softline: u, hardline: i }, utils: { replaceTextEndOfLine: l } } = qe(), { locStart: p, locEnd: y } = au(), { forceBreakChildren: h, forceNextEmptyLine: g, isTextLikeNode: c, hasPrettierIgnore: f2, preferHardlineAsLeadingSpaces: F } = Rt(), { printOpeningTagPrefix: _2, needsToBorrowNextOpeningTagStartMarker: w, printOpeningTagStartMarker: E, needsToBorrowPrevClosingTagEndMarker: N, printClosingTagEndMarker: x, printClosingTagSuffix: I, needsToBorrowParentClosingTagStartMarker: P } = ur();
                        function $(m, C, o) {
                            let d = m.getValue();
                            return f2(d) ? [
                                _2(d, C),
                                ...l(C.originalText.slice(p(d) + (d.prev && w(d.prev) ? E(d).length : 0), y(d) - (d.next && N(d.next) ? x(d, C).length : 0))),
                                I(d, C)
                            ] : o();
                        }
                        function D(m, C) {
                            return c(m) && c(C) ? m.isTrailingSpaceSensitive ? m.hasTrailingSpaces ? F(C) ? i : n : "" : F(C) ? i : u : w(m) && (f2(C) || C.firstChild || C.isSelfClosing || C.type === "element" && C.attrs.length > 0) || m.type === "element" && m.isSelfClosing && N(C) ? "" : !C.isLeadingSpaceSensitive || F(C) || N(C) && m.lastChild && P(m.lastChild) && m.lastChild.lastChild && P(m.lastChild.lastChild) ? i : C.hasLeadingSpaces ? n : u;
                        }
                        function T(m, C, o) {
                            let d = m.getValue();
                            if (h(d)) return [
                                t1,
                                ...m.map((S)=>{
                                    let b = S.getValue(), B = b.prev ? D(b.prev, b) : "";
                                    return [
                                        B ? [
                                            B,
                                            g(b.prev) ? i : ""
                                        ] : "",
                                        $(S, C, o)
                                    ];
                                }, "children")
                            ];
                            let v = d.children.map(()=>Symbol(""));
                            return m.map((S, b)=>{
                                let B = S.getValue();
                                if (c(B)) {
                                    if (B.prev && c(B.prev)) {
                                        let Q = D(B.prev, B);
                                        if (Q) return g(B.prev) ? [
                                            i,
                                            i,
                                            $(S, C, o)
                                        ] : [
                                            Q,
                                            $(S, C, o)
                                        ];
                                    }
                                    return $(S, C, o);
                                }
                                let k = [], M = [], R = [], q = [], J = B.prev ? D(B.prev, B) : "", L = B.next ? D(B, B.next) : "";
                                return J && (g(B.prev) ? k.push(i, i) : J === i ? k.push(i) : c(B.prev) ? M.push(J) : M.push(a2("", u, {
                                    groupId: v[b - 1]
                                }))), L && (g(B) ? c(B.next) && q.push(i, i) : L === i ? c(B.next) && q.push(i) : R.push(L)), [
                                    ...k,
                                    s([
                                        ...M,
                                        s([
                                            $(S, C, o),
                                            ...R
                                        ], {
                                            id: v[b]
                                        })
                                    ]),
                                    ...q
                                ];
                            }, "children");
                        }
                        r.exports = {
                            printChildren: T
                        };
                    }
                }), wg = te({
                    "src/language-html/print/element.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { breakParent: t1, dedentToRoot: s, group: a2, ifBreak: n, indentIfBreak: u, indent: i, line: l, softline: p }, utils: { replaceTextEndOfLine: y } } = qe(), h = Lo(), { shouldPreserveContent: g, isScriptLikeTag: c, isVueCustomBlock: f2, countParents: F, forceBreakContent: _2 } = Rt(), { printOpeningTagPrefix: w, printOpeningTag: E, printClosingTagSuffix: N, printClosingTag: x, needsToBorrowPrevClosingTagEndMarker: I, needsToBorrowLastChildClosingTagEndMarker: P } = ur(), { printChildren: $ } = Oo();
                        function D(T, m, C) {
                            let o = T.getValue();
                            if (g(o, m)) return [
                                w(o, m),
                                a2(E(T, m, C)),
                                ...y(h(o, m)),
                                ...x(o, m),
                                N(o, m)
                            ];
                            let d = o.children.length === 1 && o.firstChild.type === "interpolation" && o.firstChild.isLeadingSpaceSensitive && !o.firstChild.hasLeadingSpaces && o.lastChild.isTrailingSpaceSensitive && !o.lastChild.hasTrailingSpaces, v = Symbol("element-attr-group-id"), S = (M)=>a2([
                                    a2(E(T, m, C), {
                                        id: v
                                    }),
                                    M,
                                    x(o, m)
                                ]), b = (M)=>d ? u(M, {
                                    groupId: v
                                }) : (c(o) || f2(o, m)) && o.parent.type === "root" && m.parser === "vue" && !m.vueIndentScriptAndStyle ? M : i(M), B = ()=>d ? n(p, "", {
                                    groupId: v
                                }) : o.firstChild.hasLeadingSpaces && o.firstChild.isLeadingSpaceSensitive ? l : o.firstChild.type === "text" && o.isWhitespaceSensitive && o.isIndentationSensitive ? s(p) : p, k = ()=>(o.next ? I(o.next) : P(o.parent)) ? o.lastChild.hasTrailingSpaces && o.lastChild.isTrailingSpaceSensitive ? " " : "" : d ? n(p, "", {
                                    groupId: v
                                }) : o.lastChild.hasTrailingSpaces && o.lastChild.isTrailingSpaceSensitive ? l : (o.lastChild.type === "comment" || o.lastChild.type === "text" && o.isWhitespaceSensitive && o.isIndentationSensitive) && new RegExp(`\\n[\\t ]{${m.tabWidth * F(T, (R)=>R.parent && R.parent.type !== "root")}}$`).test(o.lastChild.value) ? "" : p;
                            return o.children.length === 0 ? S(o.hasDanglingSpaces && o.isDanglingSpaceSensitive ? l : "") : S([
                                _2(o) ? t1 : "",
                                b([
                                    B(),
                                    $(T, m, C)
                                ]),
                                k()
                            ]);
                        }
                        r.exports = {
                            printElement: D
                        };
                    }
                }), _g = te({
                    "src/language-html/printer-html.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { fill: t1, group: s, hardline: a2, literalline: n }, utils: { cleanDoc: u, getDocParts: i, isConcat: l, replaceTextEndOfLine: p } } = qe(), y = gg(), { countChars: h, unescapeQuoteEntities: g, getTextValueParts: c } = Rt(), f2 = Sg(), { insertPragma: F } = xg(), { locStart: _2, locEnd: w } = au(), E = Ng(), { printClosingTagSuffix: N, printClosingTagEnd: x, printOpeningTagPrefix: I, printOpeningTagStart: P } = ur(), { printElement: $ } = wg(), { printChildren: D } = Oo();
                        function T(m, C, o) {
                            let d = m.getValue();
                            switch(d.type){
                                case "front-matter":
                                    return p(d.raw);
                                case "root":
                                    return C.__onHtmlRoot && C.__onHtmlRoot(d), [
                                        s(D(m, C, o)),
                                        a2
                                    ];
                                case "element":
                                case "ieConditionalComment":
                                    return $(m, C, o);
                                case "ieConditionalStartComment":
                                case "ieConditionalEndComment":
                                    return [
                                        P(d),
                                        x(d)
                                    ];
                                case "interpolation":
                                    return [
                                        P(d, C),
                                        ...m.map(o, "children"),
                                        x(d, C)
                                    ];
                                case "text":
                                    {
                                        if (d.parent.type === "interpolation") {
                                            let S = /\n[^\S\n]*$/, b = S.test(d.value), B = b ? d.value.replace(S, "") : d.value;
                                            return [
                                                ...p(B),
                                                b ? a2 : ""
                                            ];
                                        }
                                        let v = u([
                                            I(d, C),
                                            ...c(d),
                                            N(d, C)
                                        ]);
                                        return l(v) || v.type === "fill" ? t1(i(v)) : v;
                                    }
                                case "docType":
                                    return [
                                        s([
                                            P(d, C),
                                            " ",
                                            d.value.replace(/^html\b/i, "html").replace(/\s+/g, " ")
                                        ]),
                                        x(d, C)
                                    ];
                                case "comment":
                                    return [
                                        I(d, C),
                                        ...p(C.originalText.slice(_2(d), w(d)), n),
                                        N(d, C)
                                    ];
                                case "attribute":
                                    {
                                        if (d.value === null) return d.rawName;
                                        let v = g(d.value), S = h(v, "'"), b = h(v, '"'), B = S < b ? "'" : '"';
                                        return [
                                            d.rawName,
                                            "=",
                                            B,
                                            ...p(B === '"' ? v.replace(/"/g, "&quot;") : v.replace(/'/g, "&apos;")),
                                            B
                                        ];
                                    }
                                default:
                                    throw new Error(`Unexpected node type ${d.type}`);
                            }
                        }
                        r.exports = {
                            preprocess: f2,
                            print: T,
                            insertPragma: F,
                            massageAstNode: y,
                            embed: E
                        };
                    }
                }), Pg = te({
                    "src/language-html/options.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Mt(), s = "HTML";
                        r.exports = {
                            bracketSameLine: t1.bracketSameLine,
                            htmlWhitespaceSensitivity: {
                                since: "1.15.0",
                                category: s,
                                type: "choice",
                                default: "css",
                                description: "How to handle whitespaces in HTML.",
                                choices: [
                                    {
                                        value: "css",
                                        description: "Respect the default value of CSS display property."
                                    },
                                    {
                                        value: "strict",
                                        description: "Whitespaces are considered sensitive."
                                    },
                                    {
                                        value: "ignore",
                                        description: "Whitespaces are considered insensitive."
                                    }
                                ]
                            },
                            singleAttributePerLine: t1.singleAttributePerLine,
                            vueIndentScriptAndStyle: {
                                since: "1.19.0",
                                category: s,
                                type: "boolean",
                                default: false,
                                description: "Indent script and style tags in Vue files."
                            }
                        };
                    }
                }), Ig = te({
                    "src/language-html/parsers.js" () {
                        ne();
                    }
                }), On = te({
                    "node_modules/linguist-languages/data/HTML.json" (e, r) {
                        r.exports = {
                            name: "HTML",
                            type: "markup",
                            tmScope: "text.html.basic",
                            aceMode: "html",
                            codemirrorMode: "htmlmixed",
                            codemirrorMimeType: "text/html",
                            color: "#e34c26",
                            aliases: [
                                "xhtml"
                            ],
                            extensions: [
                                ".html",
                                ".hta",
                                ".htm",
                                ".html.hl",
                                ".inc",
                                ".xht",
                                ".xhtml"
                            ],
                            languageId: 146
                        };
                    }
                }), kg = te({
                    "node_modules/linguist-languages/data/Vue.json" (e, r) {
                        r.exports = {
                            name: "Vue",
                            type: "markup",
                            color: "#41b883",
                            extensions: [
                                ".vue"
                            ],
                            tmScope: "text.html.vue",
                            aceMode: "html",
                            languageId: 391
                        };
                    }
                }), Lg = te({
                    "src/language-html/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = _t(), s = _g(), a2 = Pg(), n = Ig(), u = [
                            t1(On(), ()=>({
                                    name: "Angular",
                                    since: "1.15.0",
                                    parsers: [
                                        "angular"
                                    ],
                                    vscodeLanguageIds: [
                                        "html"
                                    ],
                                    extensions: [
                                        ".component.html"
                                    ],
                                    filenames: []
                                })),
                            t1(On(), (l)=>({
                                    since: "1.15.0",
                                    parsers: [
                                        "html"
                                    ],
                                    vscodeLanguageIds: [
                                        "html"
                                    ],
                                    extensions: [
                                        ...l.extensions,
                                        ".mjml"
                                    ]
                                })),
                            t1(On(), ()=>({
                                    name: "Lightning Web Components",
                                    since: "1.17.0",
                                    parsers: [
                                        "lwc"
                                    ],
                                    vscodeLanguageIds: [
                                        "html"
                                    ],
                                    extensions: [],
                                    filenames: []
                                })),
                            t1(kg(), ()=>({
                                    since: "1.10.0",
                                    parsers: [
                                        "vue"
                                    ],
                                    vscodeLanguageIds: [
                                        "vue"
                                    ]
                                }))
                        ], i = {
                            html: s
                        };
                        r.exports = {
                            languages: u,
                            printers: i,
                            options: a2,
                            parsers: n
                        };
                    }
                }), Og = te({
                    "src/language-yaml/pragma.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(n) {
                            return /^\s*@(?:prettier|format)\s*$/.test(n);
                        }
                        function s(n) {
                            return /^\s*#[^\S\n]*@(?:prettier|format)\s*?(?:\n|$)/.test(n);
                        }
                        function a2(n) {
                            return `# @format

${n}`;
                        }
                        r.exports = {
                            isPragma: t1,
                            hasPragma: s,
                            insertPragma: a2
                        };
                    }
                }), jg = te({
                    "src/language-yaml/loc.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(a2) {
                            return a2.position.start.offset;
                        }
                        function s(a2) {
                            return a2.position.end.offset;
                        }
                        r.exports = {
                            locStart: t1,
                            locEnd: s
                        };
                    }
                }), qg = te({
                    "src/language-yaml/embed.js" (e, r) {
                        "use strict";
                        ne();
                        function t1(s, a2, n, u) {
                            if (s.getValue().type === "root" && u.filepath && /(?:[/\\]|^)\.(?:prettier|stylelint|lintstaged)rc$/.test(u.filepath)) return n(u.originalText, Object.assign(Object.assign({}, u), {}, {
                                parser: "json"
                            }));
                        }
                        r.exports = t1;
                    }
                }), $t = te({
                    "src/language-yaml/utils.js" (e, r) {
                        "use strict";
                        ne();
                        var { getLast: t1, isNonEmptyArray: s } = Ue();
                        function a2(D, T) {
                            let m = 0, C = D.stack.length - 1;
                            for(let o = 0; o < C; o++){
                                let d = D.stack[o];
                                n(d) && T(d) && m++;
                            }
                            return m;
                        }
                        function n(D, T) {
                            return D && typeof D.type == "string" && (!T || T.includes(D.type));
                        }
                        function u(D, T, m) {
                            return T("children" in D ? Object.assign(Object.assign({}, D), {}, {
                                children: D.children.map((C)=>u(C, T, D))
                            }) : D, m);
                        }
                        function i(D, T, m) {
                            Object.defineProperty(D, T, {
                                get: m,
                                enumerable: false
                            });
                        }
                        function l(D, T) {
                            let m = 0, C = T.length;
                            for(let o = D.position.end.offset - 1; o < C; o++){
                                let d = T[o];
                                if (d === `
` && m++, m === 1 && /\S/.test(d)) return false;
                                if (m === 2) return true;
                            }
                            return false;
                        }
                        function p(D) {
                            switch(D.getValue().type){
                                case "tag":
                                case "anchor":
                                case "comment":
                                    return false;
                            }
                            let m = D.stack.length;
                            for(let C = 1; C < m; C++){
                                let o = D.stack[C], d = D.stack[C - 1];
                                if (Array.isArray(d) && typeof o == "number" && o !== d.length - 1) return false;
                            }
                            return true;
                        }
                        function y(D) {
                            return s(D.children) ? y(t1(D.children)) : D;
                        }
                        function h(D) {
                            return D.value.trim() === "prettier-ignore";
                        }
                        function g(D) {
                            let T = D.getValue();
                            if (T.type === "documentBody") {
                                let m = D.getParentNode();
                                return N(m.head) && h(t1(m.head.endComments));
                            }
                            return F(T) && h(t1(T.leadingComments));
                        }
                        function c(D) {
                            return !s(D.children) && !f2(D);
                        }
                        function f2(D) {
                            return F(D) || _2(D) || w(D) || E(D) || N(D);
                        }
                        function F(D) {
                            return s(D == null ? void 0 : D.leadingComments);
                        }
                        function _2(D) {
                            return s(D == null ? void 0 : D.middleComments);
                        }
                        function w(D) {
                            return D == null ? void 0 : D.indicatorComment;
                        }
                        function E(D) {
                            return D == null ? void 0 : D.trailingComment;
                        }
                        function N(D) {
                            return s(D == null ? void 0 : D.endComments);
                        }
                        function x(D) {
                            let T = [], m;
                            for (let C of D.split(/( +)/))C !== " " ? m === " " ? T.push(C) : T.push((T.pop() || "") + C) : m === void 0 && T.unshift(""), m = C;
                            return m === " " && T.push((T.pop() || "") + " "), T[0] === "" && (T.shift(), T.unshift(" " + (T.shift() || ""))), T;
                        }
                        function I(D, T, m) {
                            let C = T.split(`
`).map((o, d, v)=>d === 0 && d === v.length - 1 ? o : d !== 0 && d !== v.length - 1 ? o.trim() : d === 0 ? o.trimEnd() : o.trimStart());
                            return m.proseWrap === "preserve" ? C.map((o)=>o.length === 0 ? [] : [
                                    o
                                ]) : C.map((o)=>o.length === 0 ? [] : x(o)).reduce((o, d, v)=>v !== 0 && C[v - 1].length > 0 && d.length > 0 && !(D === "quoteDouble" && t1(t1(o)).endsWith("\\")) ? [
                                    ...o.slice(0, -1),
                                    [
                                        ...t1(o),
                                        ...d
                                    ]
                                ] : [
                                    ...o,
                                    d
                                ], []).map((o)=>m.proseWrap === "never" ? [
                                    o.join(" ")
                                ] : o);
                        }
                        function P(D, T) {
                            let { parentIndent: m, isLastDescendant: C, options: o } = T, d = D.position.start.line === D.position.end.line ? "" : o.originalText.slice(D.position.start.offset, D.position.end.offset).match(RegExp("^[^\\n]*\\n(.*)$", "s"))[1], v;
                            if (D.indent === null) {
                                let B = d.match(RegExp("^(?<leadingSpace> *)[^\\n\\r ]", "m"));
                                v = B ? B.groups.leadingSpace.length : Number.POSITIVE_INFINITY;
                            } else v = D.indent - 1 + m;
                            let S = d.split(`
`).map((B)=>B.slice(v));
                            if (o.proseWrap === "preserve" || D.type === "blockLiteral") return b(S.map((B)=>B.length === 0 ? [] : [
                                    B
                                ]));
                            return b(S.map((B)=>B.length === 0 ? [] : x(B)).reduce((B, k, M)=>M !== 0 && S[M - 1].length > 0 && k.length > 0 && !/^\s/.test(k[0]) && !/^\s|\s$/.test(t1(B)) ? [
                                    ...B.slice(0, -1),
                                    [
                                        ...t1(B),
                                        ...k
                                    ]
                                ] : [
                                    ...B,
                                    k
                                ], []).map((B)=>B.reduce((k, M)=>k.length > 0 && /\s$/.test(t1(k)) ? [
                                        ...k.slice(0, -1),
                                        t1(k) + " " + M
                                    ] : [
                                        ...k,
                                        M
                                    ], [])).map((B)=>o.proseWrap === "never" ? [
                                    B.join(" ")
                                ] : B));
                            function b(B) {
                                if (D.chomping === "keep") return t1(B).length === 0 ? B.slice(0, -1) : B;
                                let k = 0;
                                for(let M = B.length - 1; M >= 0 && B[M].length === 0; M--)k++;
                                return k === 0 ? B : k >= 2 && !C ? B.slice(0, -(k - 1)) : B.slice(0, -k);
                            }
                        }
                        function $(D) {
                            if (!D) return true;
                            switch(D.type){
                                case "plain":
                                case "quoteDouble":
                                case "quoteSingle":
                                case "alias":
                                case "flowMapping":
                                case "flowSequence":
                                    return true;
                                default:
                                    return false;
                            }
                        }
                        r.exports = {
                            getLast: t1,
                            getAncestorCount: a2,
                            isNode: n,
                            isEmptyNode: c,
                            isInlineNode: $,
                            mapNode: u,
                            defineShortcut: i,
                            isNextLineEmpty: l,
                            isLastDescendantNode: p,
                            getBlockValueLineContents: P,
                            getFlowScalarLineContents: I,
                            getLastDescendantNode: y,
                            hasPrettierIgnore: g,
                            hasLeadingComments: F,
                            hasMiddleComments: _2,
                            hasIndicatorComment: w,
                            hasTrailingComment: E,
                            hasEndComments: N
                        };
                    }
                }), Mg = te({
                    "src/language-yaml/print-preprocess.js" (e, r) {
                        "use strict";
                        ne();
                        var { defineShortcut: t1, mapNode: s } = $t();
                        function a2(u) {
                            return s(u, n);
                        }
                        function n(u) {
                            switch(u.type){
                                case "document":
                                    t1(u, "head", ()=>u.children[0]), t1(u, "body", ()=>u.children[1]);
                                    break;
                                case "documentBody":
                                case "sequenceItem":
                                case "flowSequenceItem":
                                case "mappingKey":
                                case "mappingValue":
                                    t1(u, "content", ()=>u.children[0]);
                                    break;
                                case "mappingItem":
                                case "flowMappingItem":
                                    t1(u, "key", ()=>u.children[0]), t1(u, "value", ()=>u.children[1]);
                                    break;
                            }
                            return u;
                        }
                        r.exports = a2;
                    }
                }), Mr = te({
                    "src/language-yaml/print/misc.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { softline: t1, align: s } } = qe(), { hasEndComments: a2, isNextLineEmpty: n, isNode: u } = $t(), i = /* @__PURE__ */ new WeakMap();
                        function l(h, g) {
                            let c = h.getValue(), f2 = h.stack[0], F;
                            return i.has(f2) ? F = i.get(f2) : (F = /* @__PURE__ */ new Set(), i.set(f2, F)), !F.has(c.position.end.line) && (F.add(c.position.end.line), n(c, g) && !p(h.getParentNode())) ? t1 : "";
                        }
                        function p(h) {
                            return a2(h) && !u(h, [
                                "documentHead",
                                "documentBody",
                                "flowMapping",
                                "flowSequence"
                            ]);
                        }
                        function y(h, g) {
                            return s(" ".repeat(h), g);
                        }
                        r.exports = {
                            alignWithSpaces: y,
                            shouldPrintEndComments: p,
                            printNextEmptyLine: l
                        };
                    }
                }), Rg = te({
                    "src/language-yaml/print/flow-mapping-sequence.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { ifBreak: t1, line: s, softline: a2, hardline: n, join: u } } = qe(), { isEmptyNode: i, getLast: l, hasEndComments: p } = $t(), { printNextEmptyLine: y, alignWithSpaces: h } = Mr();
                        function g(f2, F, _2) {
                            let w = f2.getValue(), E = w.type === "flowMapping", N = E ? "{" : "[", x = E ? "}" : "]", I = a2;
                            E && w.children.length > 0 && _2.bracketSpacing && (I = s);
                            let P = l(w.children), $ = P && P.type === "flowMappingItem" && i(P.key) && i(P.value);
                            return [
                                N,
                                h(_2.tabWidth, [
                                    I,
                                    c(f2, F, _2),
                                    _2.trailingComma === "none" ? "" : t1(","),
                                    p(w) ? [
                                        n,
                                        u(n, f2.map(F, "endComments"))
                                    ] : ""
                                ]),
                                $ ? "" : I,
                                x
                            ];
                        }
                        function c(f2, F, _2) {
                            let w = f2.getValue();
                            return f2.map((N, x)=>[
                                    F(),
                                    x === w.children.length - 1 ? "" : [
                                        ",",
                                        s,
                                        w.children[x].position.start.line !== w.children[x + 1].position.start.line ? y(N, _2.originalText) : ""
                                    ]
                                ], "children");
                        }
                        r.exports = {
                            printFlowMapping: g,
                            printFlowSequence: g
                        };
                    }
                }), $g = te({
                    "src/language-yaml/print/mapping-item.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { conditionalGroup: t1, group: s, hardline: a2, ifBreak: n, join: u, line: i } } = qe(), { hasLeadingComments: l, hasMiddleComments: p, hasTrailingComment: y, hasEndComments: h, isNode: g, isEmptyNode: c, isInlineNode: f2 } = $t(), { alignWithSpaces: F } = Mr();
                        function _2(x, I, P, $, D) {
                            let { key: T, value: m } = x, C = c(T), o = c(m);
                            if (C && o) return ": ";
                            let d = $("key"), v = E(x) ? " " : "";
                            if (o) return x.type === "flowMappingItem" && I.type === "flowMapping" ? d : x.type === "mappingItem" && w(T.content, D) && !y(T.content) && (!I.tag || I.tag.value !== "tag:yaml.org,2002:set") ? [
                                d,
                                v,
                                ":"
                            ] : [
                                "? ",
                                F(2, d)
                            ];
                            let S = $("value");
                            if (C) return [
                                ": ",
                                F(2, S)
                            ];
                            if (l(m) || !f2(T.content)) return [
                                "? ",
                                F(2, d),
                                a2,
                                u("", P.map($, "value", "leadingComments").map((q)=>[
                                        q,
                                        a2
                                    ])),
                                ": ",
                                F(2, S)
                            ];
                            if (N(T.content) && !l(T.content) && !p(T.content) && !y(T.content) && !h(T) && !l(m.content) && !p(m.content) && !h(m) && w(m.content, D)) return [
                                d,
                                v,
                                ": ",
                                S
                            ];
                            let b = Symbol("mappingKey"), B = s([
                                n("? "),
                                s(F(2, d), {
                                    id: b
                                })
                            ]), k = [
                                a2,
                                ": ",
                                F(2, S)
                            ], M = [
                                v,
                                ":"
                            ];
                            l(m.content) || h(m) && m.content && !g(m.content, [
                                "mapping",
                                "sequence"
                            ]) || I.type === "mapping" && y(T.content) && f2(m.content) || g(m.content, [
                                "mapping",
                                "sequence"
                            ]) && m.content.tag === null && m.content.anchor === null ? M.push(a2) : m.content && M.push(i), M.push(S);
                            let R = F(D.tabWidth, M);
                            return w(T.content, D) && !l(T.content) && !p(T.content) && !h(T) ? t1([
                                [
                                    d,
                                    R
                                ]
                            ]) : t1([
                                [
                                    B,
                                    n(k, R, {
                                        groupId: b
                                    })
                                ]
                            ]);
                        }
                        function w(x, I) {
                            if (!x) return true;
                            switch(x.type){
                                case "plain":
                                case "quoteSingle":
                                case "quoteDouble":
                                    break;
                                case "alias":
                                    return true;
                                default:
                                    return false;
                            }
                            if (I.proseWrap === "preserve") return x.position.start.line === x.position.end.line;
                            if (/\\$/m.test(I.originalText.slice(x.position.start.offset, x.position.end.offset))) return false;
                            switch(I.proseWrap){
                                case "never":
                                    return !x.value.includes(`
`);
                                case "always":
                                    return !/[\n ]/.test(x.value);
                                default:
                                    return false;
                            }
                        }
                        function E(x) {
                            return x.key.content && x.key.content.type === "alias";
                        }
                        function N(x) {
                            if (!x) return true;
                            switch(x.type){
                                case "plain":
                                case "quoteDouble":
                                case "quoteSingle":
                                    return x.position.start.line === x.position.end.line;
                                case "alias":
                                    return true;
                                default:
                                    return false;
                            }
                        }
                        r.exports = _2;
                    }
                }), Vg = te({
                    "src/language-yaml/print/block.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { dedent: t1, dedentToRoot: s, fill: a2, hardline: n, join: u, line: i, literalline: l, markAsRoot: p }, utils: { getDocParts: y } } = qe(), { getAncestorCount: h, getBlockValueLineContents: g, hasIndicatorComment: c, isLastDescendantNode: f2, isNode: F } = $t(), { alignWithSpaces: _2 } = Mr();
                        function w(E, N, x) {
                            let I = E.getValue(), P = h(E, (C)=>F(C, [
                                    "sequence",
                                    "mapping"
                                ])), $ = f2(E), D = [
                                I.type === "blockFolded" ? ">" : "|"
                            ];
                            I.indent !== null && D.push(I.indent.toString()), I.chomping !== "clip" && D.push(I.chomping === "keep" ? "+" : "-"), c(I) && D.push(" ", N("indicatorComment"));
                            let T = g(I, {
                                parentIndent: P,
                                isLastDescendant: $,
                                options: x
                            }), m = [];
                            for (let [C, o] of T.entries())C === 0 && m.push(n), m.push(a2(y(u(i, o)))), C !== T.length - 1 ? m.push(o.length === 0 ? n : p(l)) : I.chomping === "keep" && $ && m.push(s(o.length === 0 ? n : l));
                            return I.indent === null ? D.push(t1(_2(x.tabWidth, m))) : D.push(s(_2(I.indent - 1 + P, m))), D;
                        }
                        r.exports = w;
                    }
                }), Wg = te({
                    "src/language-yaml/printer-yaml.js" (e, r) {
                        "use strict";
                        ne();
                        var { builders: { breakParent: t1, fill: s, group: a2, hardline: n, join: u, line: i, lineSuffix: l, literalline: p }, utils: { getDocParts: y, replaceTextEndOfLine: h } } = qe(), { isPreviousLineEmpty: g } = Ue(), { insertPragma: c, isPragma: f2 } = Og(), { locStart: F } = jg(), _2 = qg(), { getFlowScalarLineContents: w, getLastDescendantNode: E, hasLeadingComments: N, hasMiddleComments: x, hasTrailingComment: I, hasEndComments: P, hasPrettierIgnore: $, isLastDescendantNode: D, isNode: T, isInlineNode: m } = $t(), C = Mg(), { alignWithSpaces: o, printNextEmptyLine: d, shouldPrintEndComments: v } = Mr(), { printFlowMapping: S, printFlowSequence: b } = Rg(), B = $g(), k = Vg();
                        function M(j, Y, ie) {
                            let ee = j.getValue(), ce = [];
                            ee.type !== "mappingValue" && N(ee) && ce.push([
                                u(n, j.map(ie, "leadingComments")),
                                n
                            ]);
                            let { tag: W, anchor: K } = ee;
                            W && ce.push(ie("tag")), W && K && ce.push(" "), K && ce.push(ie("anchor"));
                            let de = "";
                            T(ee, [
                                "mapping",
                                "sequence",
                                "comment",
                                "directive",
                                "mappingItem",
                                "sequenceItem"
                            ]) && !D(j) && (de = d(j, Y.originalText)), (W || K) && (T(ee, [
                                "sequence",
                                "mapping"
                            ]) && !x(ee) ? ce.push(n) : ce.push(" ")), x(ee) && ce.push([
                                ee.middleComments.length === 1 ? "" : n,
                                u(n, j.map(ie, "middleComments")),
                                n
                            ]);
                            let ue = j.getParentNode();
                            return $(j) ? ce.push(h(Y.originalText.slice(ee.position.start.offset, ee.position.end.offset).trimEnd(), p)) : ce.push(a2(R(ee, ue, j, Y, ie))), I(ee) && !T(ee, [
                                "document",
                                "documentHead"
                            ]) && ce.push(l([
                                ee.type === "mappingValue" && !ee.content ? "" : " ",
                                ue.type === "mappingKey" && j.getParentNode(2).type === "mapping" && m(ee) ? "" : t1,
                                ie("trailingComment")
                            ])), v(ee) && ce.push(o(ee.type === "sequenceItem" ? 2 : 0, [
                                n,
                                u(n, j.map((Fe)=>[
                                        g(Y.originalText, Fe.getValue(), F) ? n : "",
                                        ie()
                                    ], "endComments"))
                            ])), ce.push(de), ce;
                        }
                        function R(j, Y, ie, ee, ce) {
                            switch(j.type){
                                case "root":
                                    {
                                        let { children: W } = j, K = [];
                                        ie.each((ue, Fe)=>{
                                            let z = W[Fe], U = W[Fe + 1];
                                            Fe !== 0 && K.push(n), K.push(ce()), J(z, U) ? (K.push(n, "..."), I(z) && K.push(" ", ce("trailingComment"))) : U && !I(U.head) && K.push(n, "---");
                                        }, "children");
                                        let de = E(j);
                                        return (!T(de, [
                                            "blockLiteral",
                                            "blockFolded"
                                        ]) || de.chomping !== "keep") && K.push(n), K;
                                    }
                                case "document":
                                    {
                                        let W = Y.children[ie.getName() + 1], K = [];
                                        return L(j, W, Y, ee) === "head" && ((j.head.children.length > 0 || j.head.endComments.length > 0) && K.push(ce("head")), I(j.head) ? K.push([
                                            "---",
                                            " ",
                                            ce([
                                                "head",
                                                "trailingComment"
                                            ])
                                        ]) : K.push("---")), q(j) && K.push(ce("body")), u(n, K);
                                    }
                                case "documentHead":
                                    return u(n, [
                                        ...ie.map(ce, "children"),
                                        ...ie.map(ce, "endComments")
                                    ]);
                                case "documentBody":
                                    {
                                        let { children: W, endComments: K } = j, de = "";
                                        if (W.length > 0 && K.length > 0) {
                                            let ue = E(j);
                                            T(ue, [
                                                "blockFolded",
                                                "blockLiteral"
                                            ]) ? ue.chomping !== "keep" && (de = [
                                                n,
                                                n
                                            ]) : de = n;
                                        }
                                        return [
                                            u(n, ie.map(ce, "children")),
                                            de,
                                            u(n, ie.map(ce, "endComments"))
                                        ];
                                    }
                                case "directive":
                                    return [
                                        "%",
                                        u(" ", [
                                            j.name,
                                            ...j.parameters
                                        ])
                                    ];
                                case "comment":
                                    return [
                                        "#",
                                        j.value
                                    ];
                                case "alias":
                                    return [
                                        "*",
                                        j.value
                                    ];
                                case "tag":
                                    return ee.originalText.slice(j.position.start.offset, j.position.end.offset);
                                case "anchor":
                                    return [
                                        "&",
                                        j.value
                                    ];
                                case "plain":
                                    return Q(j.type, ee.originalText.slice(j.position.start.offset, j.position.end.offset), ee);
                                case "quoteDouble":
                                case "quoteSingle":
                                    {
                                        let W = "'", K = '"', de = ee.originalText.slice(j.position.start.offset + 1, j.position.end.offset - 1);
                                        if (j.type === "quoteSingle" && de.includes("\\") || j.type === "quoteDouble" && /\\[^"]/.test(de)) {
                                            let Fe = j.type === "quoteDouble" ? K : W;
                                            return [
                                                Fe,
                                                Q(j.type, de, ee),
                                                Fe
                                            ];
                                        }
                                        if (de.includes(K)) return [
                                            W,
                                            Q(j.type, j.type === "quoteDouble" ? de.replace(/\\"/g, K).replace(/'/g, W.repeat(2)) : de, ee),
                                            W
                                        ];
                                        if (de.includes(W)) return [
                                            K,
                                            Q(j.type, j.type === "quoteSingle" ? de.replace(/''/g, W) : de, ee),
                                            K
                                        ];
                                        let ue = ee.singleQuote ? W : K;
                                        return [
                                            ue,
                                            Q(j.type, de, ee),
                                            ue
                                        ];
                                    }
                                case "blockFolded":
                                case "blockLiteral":
                                    return k(ie, ce, ee);
                                case "mapping":
                                case "sequence":
                                    return u(n, ie.map(ce, "children"));
                                case "sequenceItem":
                                    return [
                                        "- ",
                                        o(2, j.content ? ce("content") : "")
                                    ];
                                case "mappingKey":
                                case "mappingValue":
                                    return j.content ? ce("content") : "";
                                case "mappingItem":
                                case "flowMappingItem":
                                    return B(j, Y, ie, ce, ee);
                                case "flowMapping":
                                    return S(ie, ce, ee);
                                case "flowSequence":
                                    return b(ie, ce, ee);
                                case "flowSequenceItem":
                                    return ce("content");
                                default:
                                    throw new Error(`Unexpected node type ${j.type}`);
                            }
                        }
                        function q(j) {
                            return j.body.children.length > 0 || P(j.body);
                        }
                        function J(j, Y) {
                            return I(j) || Y && (Y.head.children.length > 0 || P(Y.head));
                        }
                        function L(j, Y, ie, ee) {
                            return ie.children[0] === j && /---(?:\s|$)/.test(ee.originalText.slice(F(j), F(j) + 4)) || j.head.children.length > 0 || P(j.head) || I(j.head) ? "head" : J(j, Y) ? false : Y ? "root" : false;
                        }
                        function Q(j, Y, ie) {
                            let ee = w(j, Y, ie);
                            return u(n, ee.map((ce)=>s(y(u(i, ce)))));
                        }
                        function V(j, Y) {
                            if (T(Y)) switch(delete Y.position, Y.type){
                                case "comment":
                                    if (f2(Y.value)) return null;
                                    break;
                                case "quoteDouble":
                                case "quoteSingle":
                                    Y.type = "quote";
                                    break;
                            }
                        }
                        r.exports = {
                            preprocess: C,
                            embed: _2,
                            print: M,
                            massageAstNode: V,
                            insertPragma: c
                        };
                    }
                }), Hg = te({
                    "src/language-yaml/options.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = Mt();
                        r.exports = {
                            bracketSpacing: t1.bracketSpacing,
                            singleQuote: t1.singleQuote,
                            proseWrap: t1.proseWrap
                        };
                    }
                }), Gg = te({
                    "src/language-yaml/parsers.js" () {
                        ne();
                    }
                }), Ug = te({
                    "node_modules/linguist-languages/data/YAML.json" (e, r) {
                        r.exports = {
                            name: "YAML",
                            type: "data",
                            color: "#cb171e",
                            tmScope: "source.yaml",
                            aliases: [
                                "yml"
                            ],
                            extensions: [
                                ".yml",
                                ".mir",
                                ".reek",
                                ".rviz",
                                ".sublime-syntax",
                                ".syntax",
                                ".yaml",
                                ".yaml-tmlanguage",
                                ".yaml.sed",
                                ".yml.mysql"
                            ],
                            filenames: [
                                ".clang-format",
                                ".clang-tidy",
                                ".gemrc",
                                "CITATION.cff",
                                "glide.lock",
                                "yarn.lock"
                            ],
                            aceMode: "yaml",
                            codemirrorMode: "yaml",
                            codemirrorMimeType: "text/x-yaml",
                            languageId: 407
                        };
                    }
                }), Jg = te({
                    "src/language-yaml/index.js" (e, r) {
                        "use strict";
                        ne();
                        var t1 = _t(), s = Wg(), a2 = Hg(), n = Gg(), u = [
                            t1(Ug(), (i)=>({
                                    since: "1.14.0",
                                    parsers: [
                                        "yaml"
                                    ],
                                    vscodeLanguageIds: [
                                        "yaml",
                                        "ansible",
                                        "home-assistant"
                                    ],
                                    filenames: [
                                        ...i.filenames.filter((l)=>l !== "yarn.lock"),
                                        ".prettierrc",
                                        ".stylelintrc",
                                        ".lintstagedrc"
                                    ]
                                }))
                        ];
                        r.exports = {
                            languages: u,
                            printers: {
                                yaml: s
                            },
                            options: a2,
                            parsers: n
                        };
                    }
                }), zg = te({
                    "src/languages.js" (e, r) {
                        "use strict";
                        ne(), r.exports = [
                            Bd(),
                            Ud(),
                            eg(),
                            ag(),
                            dg(),
                            Lg(),
                            Jg()
                        ];
                    }
                });
                ne();
                var { version: Xg } = Ia(), Ot = Gm(), { getSupportInfo: Kg } = Xn(), Yg = Um(), Qg = zg(), Zg = qe();
                function Nt(e) {
                    let r = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
                    return function() {
                        for(var t1 = arguments.length, s = new Array(t1), a2 = 0; a2 < t1; a2++)s[a2] = arguments[a2];
                        let n = s[r] || {}, u = n.plugins || [];
                        return s[r] = Object.assign(Object.assign({}, n), {}, {
                            plugins: [
                                ...Qg,
                                ...Array.isArray(u) ? u : Object.values(u)
                            ]
                        }), e(...s);
                    };
                }
                var jn = Nt(Ot.formatWithCursor);
                jo.exports = {
                    formatWithCursor: jn,
                    format (e, r) {
                        return jn(e, r).formatted;
                    },
                    check (e, r) {
                        let { formatted: t1 } = jn(e, r);
                        return t1 === e;
                    },
                    doc: Zg,
                    getSupportInfo: Nt(Kg, 0),
                    version: Xg,
                    util: Yg,
                    __debug: {
                        parse: Nt(Ot.parse),
                        formatAST: Nt(Ot.formatAST),
                        formatDoc: Nt(Ot.formatDoc),
                        printToDoc: Nt(Ot.printToDoc),
                        printDocToString: Nt(Ot.printDocToString)
                    }
                };
            });
            return e0();
        });
    }
});
// ../../node_modules/prettier/parser-yaml.js
var require_parser_yaml = __commonJS({
    "../../node_modules/prettier/parser-yaml.js" (exports, module) {
        (function(e) {
            if (typeof exports == "object" && typeof module == "object") module.exports = e();
            else if (typeof define == "function" && __webpack_require__.amdO) define(e);
            else {
                var i = typeof globalThis < "u" ? globalThis : typeof __webpack_require__.g < "u" ? __webpack_require__.g : typeof self < "u" ? self : this || {};
                i.prettierPlugins = i.prettierPlugins || {}, i.prettierPlugins.yaml = e();
            }
        })(function() {
            "use strict";
            var yt = (n, e)=>()=>(e || n((e = {
                        exports: {}
                    }).exports, e), e.exports);
            var ln = yt((un, at)=>{
                var Ye = Object.defineProperty, bt = Object.getOwnPropertyDescriptor, De = Object.getOwnPropertyNames, wt = Object.prototype.hasOwnProperty, Ke = (n, e)=>function() {
                        return n && (e = (0, n[De(n)[0]])(n = 0)), e;
                    }, D = (n, e)=>function() {
                        return e || (0, n[De(n)[0]])((e = {
                            exports: {}
                        }).exports, e), e.exports;
                    }, St = (n, e)=>{
                    for(var r in e)Ye(n, r, {
                        get: e[r],
                        enumerable: true
                    });
                }, Et = (n, e, r, c)=>{
                    if (e && typeof e == "object" || typeof e == "function") for (let h of De(e))!wt.call(n, h) && h !== r && Ye(n, h, {
                        get: ()=>e[h],
                        enumerable: !(c = bt(e, h)) || c.enumerable
                    });
                    return n;
                }, se = (n)=>Et(Ye({}, "__esModule", {
                        value: true
                    }), n), Te, Y = Ke({
                    "<define:process>" () {
                        Te = {
                            env: {},
                            argv: []
                        };
                    }
                }), Mt = D({
                    "src/common/parser-create-error.js" (n, e) {
                        "use strict";
                        Y();
                        function r(c, h) {
                            let d = new SyntaxError(c + " (" + h.start.line + ":" + h.start.column + ")");
                            return d.loc = h, d;
                        }
                        e.exports = r;
                    }
                }), Ot = D({
                    "src/language-yaml/pragma.js" (n, e) {
                        "use strict";
                        Y();
                        function r(d) {
                            return /^\s*@(?:prettier|format)\s*$/.test(d);
                        }
                        function c(d) {
                            return /^\s*#[^\S\n]*@(?:prettier|format)\s*?(?:\n|$)/.test(d);
                        }
                        function h(d) {
                            return `# @format

${d}`;
                        }
                        e.exports = {
                            isPragma: r,
                            hasPragma: c,
                            insertPragma: h
                        };
                    }
                }), Lt = D({
                    "src/language-yaml/loc.js" (n, e) {
                        "use strict";
                        Y();
                        function r(h) {
                            return h.position.start.offset;
                        }
                        function c(h) {
                            return h.position.end.offset;
                        }
                        e.exports = {
                            locStart: r,
                            locEnd: c
                        };
                    }
                }), te = {};
                St(te, {
                    __assign: ()=>qe,
                    __asyncDelegator: ()=>Yt,
                    __asyncGenerator: ()=>jt,
                    __asyncValues: ()=>Dt,
                    __await: ()=>Ce,
                    __awaiter: ()=>Pt,
                    __classPrivateFieldGet: ()=>Qt,
                    __classPrivateFieldSet: ()=>Ut,
                    __createBinding: ()=>Rt,
                    __decorate: ()=>Tt,
                    __exportStar: ()=>qt,
                    __extends: ()=>At,
                    __generator: ()=>It,
                    __importDefault: ()=>Vt,
                    __importStar: ()=>Wt,
                    __makeTemplateObject: ()=>Ft,
                    __metadata: ()=>kt,
                    __param: ()=>Ct,
                    __read: ()=>Je,
                    __rest: ()=>Nt,
                    __spread: ()=>$t,
                    __spreadArrays: ()=>Bt,
                    __values: ()=>je
                });
                function At(n, e) {
                    Re(n, e);
                    function r() {
                        this.constructor = n;
                    }
                    n.prototype = e === null ? Object.create(e) : (r.prototype = e.prototype, new r());
                }
                function Nt(n, e) {
                    var r = {};
                    for(var c in n)Object.prototype.hasOwnProperty.call(n, c) && e.indexOf(c) < 0 && (r[c] = n[c]);
                    if (n != null && typeof Object.getOwnPropertySymbols == "function") for(var h = 0, c = Object.getOwnPropertySymbols(n); h < c.length; h++)e.indexOf(c[h]) < 0 && Object.prototype.propertyIsEnumerable.call(n, c[h]) && (r[c[h]] = n[c[h]]);
                    return r;
                }
                function Tt(n, e, r, c) {
                    var h = arguments.length, d = h < 3 ? e : c === null ? c = Object.getOwnPropertyDescriptor(e, r) : c, y;
                    if (typeof Reflect == "object" && typeof Reflect.decorate == "function") d = Reflect.decorate(n, e, r, c);
                    else for(var E = n.length - 1; E >= 0; E--)(y = n[E]) && (d = (h < 3 ? y(d) : h > 3 ? y(e, r, d) : y(e, r)) || d);
                    return h > 3 && d && Object.defineProperty(e, r, d), d;
                }
                function Ct(n, e) {
                    return function(r, c) {
                        e(r, c, n);
                    };
                }
                function kt(n, e) {
                    if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(n, e);
                }
                function Pt(n, e, r, c) {
                    function h(d) {
                        return d instanceof r ? d : new r(function(y) {
                            y(d);
                        });
                    }
                    return new (r || (r = Promise))(function(d, y) {
                        function E(M) {
                            try {
                                S(c.next(M));
                            } catch (T) {
                                y(T);
                            }
                        }
                        function I(M) {
                            try {
                                S(c.throw(M));
                            } catch (T) {
                                y(T);
                            }
                        }
                        function S(M) {
                            M.done ? d(M.value) : h(M.value).then(E, I);
                        }
                        S((c = c.apply(n, e || [])).next());
                    });
                }
                function It(n, e) {
                    var r = {
                        label: 0,
                        sent: function() {
                            if (d[0] & 1) throw d[1];
                            return d[1];
                        },
                        trys: [],
                        ops: []
                    }, c, h, d, y;
                    return y = {
                        next: E(0),
                        throw: E(1),
                        return: E(2)
                    }, typeof Symbol == "function" && (y[Symbol.iterator] = function() {
                        return this;
                    }), y;
                    function E(S) {
                        return function(M) {
                            return I([
                                S,
                                M
                            ]);
                        };
                    }
                    function I(S) {
                        if (c) throw new TypeError("Generator is already executing.");
                        for(; r;)try {
                            if (c = 1, h && (d = S[0] & 2 ? h.return : S[0] ? h.throw || ((d = h.return) && d.call(h), 0) : h.next) && !(d = d.call(h, S[1])).done) return d;
                            switch(h = 0, d && (S = [
                                S[0] & 2,
                                d.value
                            ]), S[0]){
                                case 0:
                                case 1:
                                    d = S;
                                    break;
                                case 4:
                                    return r.label++, {
                                        value: S[1],
                                        done: false
                                    };
                                case 5:
                                    r.label++, h = S[1], S = [
                                        0
                                    ];
                                    continue;
                                case 7:
                                    S = r.ops.pop(), r.trys.pop();
                                    continue;
                                default:
                                    if (d = r.trys, !(d = d.length > 0 && d[d.length - 1]) && (S[0] === 6 || S[0] === 2)) {
                                        r = 0;
                                        continue;
                                    }
                                    if (S[0] === 3 && (!d || S[1] > d[0] && S[1] < d[3])) {
                                        r.label = S[1];
                                        break;
                                    }
                                    if (S[0] === 6 && r.label < d[1]) {
                                        r.label = d[1], d = S;
                                        break;
                                    }
                                    if (d && r.label < d[2]) {
                                        r.label = d[2], r.ops.push(S);
                                        break;
                                    }
                                    d[2] && r.ops.pop(), r.trys.pop();
                                    continue;
                            }
                            S = e.call(n, r);
                        } catch (M) {
                            S = [
                                6,
                                M
                            ], h = 0;
                        } finally{
                            c = d = 0;
                        }
                        if (S[0] & 5) throw S[1];
                        return {
                            value: S[0] ? S[1] : void 0,
                            done: true
                        };
                    }
                }
                function Rt(n, e, r, c) {
                    c === void 0 && (c = r), n[c] = e[r];
                }
                function qt(n, e) {
                    for(var r in n)r !== "default" && !e.hasOwnProperty(r) && (e[r] = n[r]);
                }
                function je(n) {
                    var e = typeof Symbol == "function" && Symbol.iterator, r = e && n[e], c = 0;
                    if (r) return r.call(n);
                    if (n && typeof n.length == "number") return {
                        next: function() {
                            return n && c >= n.length && (n = void 0), {
                                value: n && n[c++],
                                done: !n
                            };
                        }
                    };
                    throw new TypeError(e ? "Object is not iterable." : "Symbol.iterator is not defined.");
                }
                function Je(n, e) {
                    var r = typeof Symbol == "function" && n[Symbol.iterator];
                    if (!r) return n;
                    var c = r.call(n), h, d = [], y;
                    try {
                        for(; (e === void 0 || e-- > 0) && !(h = c.next()).done;)d.push(h.value);
                    } catch (E) {
                        y = {
                            error: E
                        };
                    } finally{
                        try {
                            h && !h.done && (r = c.return) && r.call(c);
                        } finally{
                            if (y) throw y.error;
                        }
                    }
                    return d;
                }
                function $t() {
                    for(var n = [], e = 0; e < arguments.length; e++)n = n.concat(Je(arguments[e]));
                    return n;
                }
                function Bt() {
                    for(var n = 0, e = 0, r = arguments.length; e < r; e++)n += arguments[e].length;
                    for(var c = Array(n), h = 0, e = 0; e < r; e++)for(var d = arguments[e], y = 0, E = d.length; y < E; y++, h++)c[h] = d[y];
                    return c;
                }
                function Ce(n) {
                    return this instanceof Ce ? (this.v = n, this) : new Ce(n);
                }
                function jt(n, e, r) {
                    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
                    var c = r.apply(n, e || []), h, d = [];
                    return h = {}, y("next"), y("throw"), y("return"), h[Symbol.asyncIterator] = function() {
                        return this;
                    }, h;
                    function y(P) {
                        c[P] && (h[P] = function(C) {
                            return new Promise(function(q, R) {
                                d.push([
                                    P,
                                    C,
                                    q,
                                    R
                                ]) > 1 || E(P, C);
                            });
                        });
                    }
                    function E(P, C) {
                        try {
                            I(c[P](C));
                        } catch (q) {
                            T(d[0][3], q);
                        }
                    }
                    function I(P) {
                        P.value instanceof Ce ? Promise.resolve(P.value.v).then(S, M) : T(d[0][2], P);
                    }
                    function S(P) {
                        E("next", P);
                    }
                    function M(P) {
                        E("throw", P);
                    }
                    function T(P, C) {
                        P(C), d.shift(), d.length && E(d[0][0], d[0][1]);
                    }
                }
                function Yt(n) {
                    var e, r;
                    return e = {}, c("next"), c("throw", function(h) {
                        throw h;
                    }), c("return"), e[Symbol.iterator] = function() {
                        return this;
                    }, e;
                    function c(h, d) {
                        e[h] = n[h] ? function(y) {
                            return (r = !r) ? {
                                value: Ce(n[h](y)),
                                done: h === "return"
                            } : d ? d(y) : y;
                        } : d;
                    }
                }
                function Dt(n) {
                    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
                    var e = n[Symbol.asyncIterator], r;
                    return e ? e.call(n) : (n = typeof je == "function" ? je(n) : n[Symbol.iterator](), r = {}, c("next"), c("throw"), c("return"), r[Symbol.asyncIterator] = function() {
                        return this;
                    }, r);
                    function c(d) {
                        r[d] = n[d] && function(y) {
                            return new Promise(function(E, I) {
                                y = n[d](y), h(E, I, y.done, y.value);
                            });
                        };
                    }
                    function h(d, y, E, I) {
                        Promise.resolve(I).then(function(S) {
                            d({
                                value: S,
                                done: E
                            });
                        }, y);
                    }
                }
                function Ft(n, e) {
                    return Object.defineProperty ? Object.defineProperty(n, "raw", {
                        value: e
                    }) : n.raw = e, n;
                }
                function Wt(n) {
                    if (n && n.__esModule) return n;
                    var e = {};
                    if (n != null) for(var r in n)Object.hasOwnProperty.call(n, r) && (e[r] = n[r]);
                    return e.default = n, e;
                }
                function Vt(n) {
                    return n && n.__esModule ? n : {
                        default: n
                    };
                }
                function Qt(n, e) {
                    if (!e.has(n)) throw new TypeError("attempted to get private field on non-instance");
                    return e.get(n);
                }
                function Ut(n, e, r) {
                    if (!e.has(n)) throw new TypeError("attempted to set private field on non-instance");
                    return e.set(n, r), r;
                }
                var Re, qe, ie = Ke({
                    "node_modules/tslib/tslib.es6.js" () {
                        Y(), Re = function(n, e) {
                            return Re = Object.setPrototypeOf || ({
                                __proto__: []
                            }) instanceof Array && function(r, c) {
                                r.__proto__ = c;
                            } || function(r, c) {
                                for(var h in c)c.hasOwnProperty(h) && (r[h] = c[h]);
                            }, Re(n, e);
                        }, qe = function() {
                            return qe = Object.assign || function(e) {
                                for(var r, c = 1, h = arguments.length; c < h; c++){
                                    r = arguments[c];
                                    for(var d in r)Object.prototype.hasOwnProperty.call(r, d) && (e[d] = r[d]);
                                }
                                return e;
                            }, qe.apply(this, arguments);
                        };
                    }
                }), Kt = D({
                    "node_modules/yaml-unist-parser/node_modules/lines-and-columns/build/index.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true, n.LinesAndColumns = void 0;
                        var e = `
`, r = "\r", c = function() {
                            function h(d) {
                                this.string = d;
                                for(var y = [
                                    0
                                ], E = 0; E < d.length;)switch(d[E]){
                                    case e:
                                        E += e.length, y.push(E);
                                        break;
                                    case r:
                                        E += r.length, d[E] === e && (E += e.length), y.push(E);
                                        break;
                                    default:
                                        E++;
                                        break;
                                }
                                this.offsets = y;
                            }
                            return h.prototype.locationForIndex = function(d) {
                                if (d < 0 || d > this.string.length) return null;
                                for(var y = 0, E = this.offsets; E[y + 1] <= d;)y++;
                                var I = d - E[y];
                                return {
                                    line: y,
                                    column: I
                                };
                            }, h.prototype.indexForLocation = function(d) {
                                var y = d.line, E = d.column;
                                return y < 0 || y >= this.offsets.length || E < 0 || E > this.lengthOfLine(y) ? null : this.offsets[y] + E;
                            }, h.prototype.lengthOfLine = function(d) {
                                var y = this.offsets[d], E = d === this.offsets.length - 1 ? this.string.length : this.offsets[d + 1];
                                return E - y;
                            }, h;
                        }();
                        n.LinesAndColumns = c, n.default = c;
                    }
                }), Jt = D({
                    "node_modules/yaml-unist-parser/lib/utils/define-parents.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r, c) {
                            c === void 0 && (c = null), "children" in r && r.children.forEach(function(h) {
                                return e(h, r);
                            }), "anchor" in r && r.anchor && e(r.anchor, r), "tag" in r && r.tag && e(r.tag, r), "leadingComments" in r && r.leadingComments.forEach(function(h) {
                                return e(h, r);
                            }), "middleComments" in r && r.middleComments.forEach(function(h) {
                                return e(h, r);
                            }), "indicatorComment" in r && r.indicatorComment && e(r.indicatorComment, r), "trailingComment" in r && r.trailingComment && e(r.trailingComment, r), "endComments" in r && r.endComments.forEach(function(h) {
                                return e(h, r);
                            }), Object.defineProperty(r, "_parent", {
                                value: c,
                                enumerable: false
                            });
                        }
                        n.defineParents = e;
                    }
                }), Fe = D({
                    "node_modules/yaml-unist-parser/lib/utils/get-point-text.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r) {
                            return r.line + ":" + r.column;
                        }
                        n.getPointText = e;
                    }
                }), xt = D({
                    "node_modules/yaml-unist-parser/lib/attach.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Jt(), r = Fe();
                        function c(S) {
                            e.defineParents(S);
                            var M = h(S), T = S.children.slice();
                            S.comments.sort(function(P, C) {
                                return P.position.start.offset - C.position.end.offset;
                            }).filter(function(P) {
                                return !P._parent;
                            }).forEach(function(P) {
                                for(; T.length > 1 && P.position.start.line > T[0].position.end.line;)T.shift();
                                y(P, M, T[0]);
                            });
                        }
                        n.attachComments = c;
                        function h(S) {
                            for(var M = Array.from(new Array(S.position.end.line), function() {
                                return {};
                            }), T = 0, P = S.comments; T < P.length; T++){
                                var C = P[T];
                                M[C.position.start.line - 1].comment = C;
                            }
                            return d(M, S), M;
                        }
                        function d(S, M) {
                            if (M.position.start.offset !== M.position.end.offset) {
                                if ("leadingComments" in M) {
                                    var T = M.position.start, P = S[T.line - 1].leadingAttachableNode;
                                    (!P || T.column < P.position.start.column) && (S[T.line - 1].leadingAttachableNode = M);
                                }
                                if ("trailingComment" in M && M.position.end.column > 1 && M.type !== "document" && M.type !== "documentHead") {
                                    var C = M.position.end, q = S[C.line - 1].trailingAttachableNode;
                                    (!q || C.column >= q.position.end.column) && (S[C.line - 1].trailingAttachableNode = M);
                                }
                                if (M.type !== "root" && M.type !== "document" && M.type !== "documentHead" && M.type !== "documentBody") for(var R = M.position, T = R.start, C = R.end, B = [
                                    C.line
                                ].concat(T.line === C.line ? [] : T.line), U = 0, f2 = B; U < f2.length; U++){
                                    var i = f2[U], t1 = S[i - 1].trailingNode;
                                    (!t1 || C.column >= t1.position.end.column) && (S[i - 1].trailingNode = M);
                                }
                                "children" in M && M.children.forEach(function(s) {
                                    d(S, s);
                                });
                            }
                        }
                        function y(S, M, T) {
                            var P = S.position.start.line, C = M[P - 1].trailingAttachableNode;
                            if (C) {
                                if (C.trailingComment) throw new Error("Unexpected multiple trailing comment at " + r.getPointText(S.position.start));
                                e.defineParents(S, C), C.trailingComment = S;
                                return;
                            }
                            for(var q = P; q >= T.position.start.line; q--){
                                var R = M[q - 1].trailingNode, B = void 0;
                                if (R) B = R;
                                else if (q !== P && M[q - 1].comment) B = M[q - 1].comment._parent;
                                else continue;
                                if ((B.type === "sequence" || B.type === "mapping") && (B = B.children[0]), B.type === "mappingItem") {
                                    var U = B.children, f2 = U[0], i = U[1];
                                    B = I(f2) ? f2 : i;
                                }
                                for(;;){
                                    if (E(B, S)) {
                                        e.defineParents(S, B), B.endComments.push(S);
                                        return;
                                    }
                                    if (!B._parent) break;
                                    B = B._parent;
                                }
                                break;
                            }
                            for(var q = P + 1; q <= T.position.end.line; q++){
                                var t1 = M[q - 1].leadingAttachableNode;
                                if (t1) {
                                    e.defineParents(S, t1), t1.leadingComments.push(S);
                                    return;
                                }
                            }
                            var s = T.children[1];
                            e.defineParents(S, s), s.endComments.push(S);
                        }
                        function E(S, M) {
                            if (S.position.start.offset < M.position.start.offset && S.position.end.offset > M.position.end.offset) switch(S.type){
                                case "flowMapping":
                                case "flowSequence":
                                    return S.children.length === 0 || M.position.start.line > S.children[S.children.length - 1].position.end.line;
                            }
                            if (M.position.end.offset < S.position.end.offset) return false;
                            switch(S.type){
                                case "sequenceItem":
                                    return M.position.start.column > S.position.start.column;
                                case "mappingKey":
                                case "mappingValue":
                                    return M.position.start.column > S._parent.position.start.column && (S.children.length === 0 || S.children.length === 1 && S.children[0].type !== "blockFolded" && S.children[0].type !== "blockLiteral") && (S.type === "mappingValue" || I(S));
                                default:
                                    return false;
                            }
                        }
                        function I(S) {
                            return S.position.start !== S.position.end && (S.children.length === 0 || S.position.start.offset !== S.children[0].position.start.offset);
                        }
                    }
                }), me = D({
                    "node_modules/yaml-unist-parser/lib/factories/node.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r, c) {
                            return {
                                type: r,
                                position: c
                            };
                        }
                        n.createNode = e;
                    }
                }), Ht = D({
                    "node_modules/yaml-unist-parser/lib/factories/root.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = me();
                        function c(h, d, y) {
                            return e.__assign(e.__assign({}, r.createNode("root", h)), {
                                children: d,
                                comments: y
                            });
                        }
                        n.createRoot = c;
                    }
                }), Gt = D({
                    "node_modules/yaml-unist-parser/lib/preprocess.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r) {
                            switch(r.type){
                                case "DOCUMENT":
                                    for(var c = r.contents.length - 1; c >= 0; c--)r.contents[c].type === "BLANK_LINE" ? r.contents.splice(c, 1) : e(r.contents[c]);
                                    for(var c = r.directives.length - 1; c >= 0; c--)r.directives[c].type === "BLANK_LINE" && r.directives.splice(c, 1);
                                    break;
                                case "FLOW_MAP":
                                case "FLOW_SEQ":
                                case "MAP":
                                case "SEQ":
                                    for(var c = r.items.length - 1; c >= 0; c--){
                                        var h = r.items[c];
                                        "char" in h || (h.type === "BLANK_LINE" ? r.items.splice(c, 1) : e(h));
                                    }
                                    break;
                                case "MAP_KEY":
                                case "MAP_VALUE":
                                case "SEQ_ITEM":
                                    r.node && e(r.node);
                                    break;
                                case "ALIAS":
                                case "BLANK_LINE":
                                case "BLOCK_FOLDED":
                                case "BLOCK_LITERAL":
                                case "COMMENT":
                                case "DIRECTIVE":
                                case "PLAIN":
                                case "QUOTE_DOUBLE":
                                case "QUOTE_SINGLE":
                                    break;
                                default:
                                    throw new Error("Unexpected node type " + JSON.stringify(r.type));
                            }
                        }
                        n.removeCstBlankLine = e;
                    }
                }), Oe = D({
                    "node_modules/yaml-unist-parser/lib/factories/leading-comment-attachable.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e() {
                            return {
                                leadingComments: []
                            };
                        }
                        n.createLeadingCommentAttachable = e;
                    }
                }), $e = D({
                    "node_modules/yaml-unist-parser/lib/factories/trailing-comment-attachable.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r) {
                            return r === void 0 && (r = null), {
                                trailingComment: r
                            };
                        }
                        n.createTrailingCommentAttachable = e;
                    }
                }), Se = D({
                    "node_modules/yaml-unist-parser/lib/factories/comment-attachable.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Oe(), c = $e();
                        function h() {
                            return e.__assign(e.__assign({}, r.createLeadingCommentAttachable()), c.createTrailingCommentAttachable());
                        }
                        n.createCommentAttachable = h;
                    }
                }), zt = D({
                    "node_modules/yaml-unist-parser/lib/factories/alias.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Se(), c = me();
                        function h(d, y, E) {
                            return e.__assign(e.__assign(e.__assign(e.__assign({}, c.createNode("alias", d)), r.createCommentAttachable()), y), {
                                value: E
                            });
                        }
                        n.createAlias = h;
                    }
                }), Zt = D({
                    "node_modules/yaml-unist-parser/lib/transforms/alias.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = zt();
                        function r(c, h) {
                            var d = c.cstNode;
                            return e.createAlias(h.transformRange({
                                origStart: d.valueRange.origStart - 1,
                                origEnd: d.valueRange.origEnd
                            }), h.transformContent(c), d.rawValue);
                        }
                        n.transformAlias = r;
                    }
                }), Xt = D({
                    "node_modules/yaml-unist-parser/lib/factories/block-folded.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te));
                        function r(c) {
                            return e.__assign(e.__assign({}, c), {
                                type: "blockFolded"
                            });
                        }
                        n.createBlockFolded = r;
                    }
                }), er = D({
                    "node_modules/yaml-unist-parser/lib/factories/block-value.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Oe(), c = me();
                        function h(d, y, E, I, S, M) {
                            return e.__assign(e.__assign(e.__assign(e.__assign({}, c.createNode("blockValue", d)), r.createLeadingCommentAttachable()), y), {
                                chomping: E,
                                indent: I,
                                value: S,
                                indicatorComment: M
                            });
                        }
                        n.createBlockValue = h;
                    }
                }), xe = D({
                    "node_modules/yaml-unist-parser/lib/constants.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e;
                        (function(r) {
                            r.Tag = "!", r.Anchor = "&", r.Comment = "#";
                        })(e = n.PropLeadingCharacter || (n.PropLeadingCharacter = {}));
                    }
                }), tr = D({
                    "node_modules/yaml-unist-parser/lib/factories/anchor.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = me();
                        function c(h, d) {
                            return e.__assign(e.__assign({}, r.createNode("anchor", h)), {
                                value: d
                            });
                        }
                        n.createAnchor = c;
                    }
                }), We = D({
                    "node_modules/yaml-unist-parser/lib/factories/comment.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = me();
                        function c(h, d) {
                            return e.__assign(e.__assign({}, r.createNode("comment", h)), {
                                value: d
                            });
                        }
                        n.createComment = c;
                    }
                }), rr = D({
                    "node_modules/yaml-unist-parser/lib/factories/content.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r, c, h) {
                            return {
                                anchor: c,
                                tag: r,
                                middleComments: h
                            };
                        }
                        n.createContent = e;
                    }
                }), nr = D({
                    "node_modules/yaml-unist-parser/lib/factories/tag.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = me();
                        function c(h, d) {
                            return e.__assign(e.__assign({}, r.createNode("tag", h)), {
                                value: d
                            });
                        }
                        n.createTag = c;
                    }
                }), He = D({
                    "node_modules/yaml-unist-parser/lib/transforms/content.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = xe(), r = tr(), c = We(), h = rr(), d = nr();
                        function y(E, I, S) {
                            S === void 0 && (S = function() {
                                return false;
                            });
                            for(var M = E.cstNode, T = [], P = null, C = null, q = null, R = 0, B = M.props; R < B.length; R++){
                                var U = B[R], f2 = I.text[U.origStart];
                                switch(f2){
                                    case e.PropLeadingCharacter.Tag:
                                        P = P || U, C = d.createTag(I.transformRange(U), E.tag);
                                        break;
                                    case e.PropLeadingCharacter.Anchor:
                                        P = P || U, q = r.createAnchor(I.transformRange(U), M.anchor);
                                        break;
                                    case e.PropLeadingCharacter.Comment:
                                        {
                                            var i = c.createComment(I.transformRange(U), I.text.slice(U.origStart + 1, U.origEnd));
                                            I.comments.push(i), !S(i) && P && P.origEnd <= U.origStart && U.origEnd <= M.valueRange.origStart && T.push(i);
                                            break;
                                        }
                                    default:
                                        throw new Error("Unexpected leading character " + JSON.stringify(f2));
                                }
                            }
                            return h.createContent(C, q, T);
                        }
                        n.transformContent = y;
                    }
                }), Ge = D({
                    "node_modules/yaml-unist-parser/lib/transforms/block-value.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = er(), r = Fe(), c = He(), h;
                        (function(y) {
                            y.CLIP = "clip", y.STRIP = "strip", y.KEEP = "keep";
                        })(h || (h = {}));
                        function d(y, E) {
                            var I = y.cstNode, S = 1, M = I.chomping === "CLIP" ? 0 : 1, T = I.header.origEnd - I.header.origStart, P = T - S - M !== 0, C = E.transformRange({
                                origStart: I.header.origStart,
                                origEnd: I.valueRange.origEnd
                            }), q = null, R = c.transformContent(y, E, function(B) {
                                var U = C.start.offset < B.position.start.offset && B.position.end.offset < C.end.offset;
                                if (!U) return false;
                                if (q) throw new Error("Unexpected multiple indicator comments at " + r.getPointText(B.position.start));
                                return q = B, true;
                            });
                            return e.createBlockValue(C, R, h[I.chomping], P ? I.blockIndent : null, I.strValue, q);
                        }
                        n.transformAstBlockValue = d;
                    }
                }), sr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/block-folded.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Xt(), r = Ge();
                        function c(h, d) {
                            return e.createBlockFolded(r.transformAstBlockValue(h, d));
                        }
                        n.transformBlockFolded = c;
                    }
                }), ir = D({
                    "node_modules/yaml-unist-parser/lib/factories/block-literal.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te));
                        function r(c) {
                            return e.__assign(e.__assign({}, c), {
                                type: "blockLiteral"
                            });
                        }
                        n.createBlockLiteral = r;
                    }
                }), ar = D({
                    "node_modules/yaml-unist-parser/lib/transforms/block-literal.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = ir(), r = Ge();
                        function c(h, d) {
                            return e.createBlockLiteral(r.transformAstBlockValue(h, d));
                        }
                        n.transformBlockLiteral = c;
                    }
                }), or = D({
                    "node_modules/yaml-unist-parser/lib/transforms/comment.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = We();
                        function r(c, h) {
                            return e.createComment(h.transformRange(c.range), c.comment);
                        }
                        n.transformComment = r;
                    }
                }), lr = D({
                    "node_modules/yaml-unist-parser/lib/factories/directive.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Se(), c = me();
                        function h(d, y, E) {
                            return e.__assign(e.__assign(e.__assign({}, c.createNode("directive", d)), r.createCommentAttachable()), {
                                name: y,
                                parameters: E
                            });
                        }
                        n.createDirective = h;
                    }
                }), Ve = D({
                    "node_modules/yaml-unist-parser/lib/utils/extract-prop-comments.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = xe(), r = We();
                        function c(h, d) {
                            for(var y = 0, E = h.props; y < E.length; y++){
                                var I = E[y], S = d.text[I.origStart];
                                switch(S){
                                    case e.PropLeadingCharacter.Comment:
                                        d.comments.push(r.createComment(d.transformRange(I), d.text.slice(I.origStart + 1, I.origEnd)));
                                        break;
                                    default:
                                        throw new Error("Unexpected leading character " + JSON.stringify(S));
                                }
                            }
                        }
                        n.extractPropComments = c;
                    }
                }), cr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/directive.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = lr(), r = Ve();
                        function c(h, d) {
                            return r.extractPropComments(h, d), e.createDirective(d.transformRange(h.range), h.name, h.parameters);
                        }
                        n.transformDirective = c;
                    }
                }), ur = D({
                    "node_modules/yaml-unist-parser/lib/factories/document.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = me(), c = $e();
                        function h(d, y, E, I) {
                            return e.__assign(e.__assign(e.__assign({}, r.createNode("document", d)), c.createTrailingCommentAttachable(I)), {
                                children: [
                                    y,
                                    E
                                ]
                            });
                        }
                        n.createDocument = h;
                    }
                }), Le = D({
                    "node_modules/yaml-unist-parser/lib/factories/position.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(c, h) {
                            return {
                                start: c,
                                end: h
                            };
                        }
                        n.createPosition = e;
                        function r(c) {
                            return {
                                start: c,
                                end: c
                            };
                        }
                        n.createEmptyPosition = r;
                    }
                }), Ee = D({
                    "node_modules/yaml-unist-parser/lib/factories/end-comment-attachable.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r) {
                            return r === void 0 && (r = []), {
                                endComments: r
                            };
                        }
                        n.createEndCommentAttachable = e;
                    }
                }), fr = D({
                    "node_modules/yaml-unist-parser/lib/factories/document-body.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Ee(), c = me();
                        function h(d, y, E) {
                            return e.__assign(e.__assign(e.__assign({}, c.createNode("documentBody", d)), r.createEndCommentAttachable(E)), {
                                children: y ? [
                                    y
                                ] : []
                            });
                        }
                        n.createDocumentBody = h;
                    }
                }), Ae = D({
                    "node_modules/yaml-unist-parser/lib/utils/get-last.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r) {
                            return r[r.length - 1];
                        }
                        n.getLast = e;
                    }
                }), ze = D({
                    "node_modules/yaml-unist-parser/lib/utils/get-match-index.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r, c) {
                            var h = r.match(c);
                            return h ? h.index : -1;
                        }
                        n.getMatchIndex = e;
                    }
                }), mr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/document-body.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = fr(), c = Ae(), h = ze(), d = Fe();
                        function y(S, M, T) {
                            var P, C = S.cstNode, q = E(C, M, T), R = q.comments, B = q.endComments, U = q.documentTrailingComment, f2 = q.documentHeadTrailingComment, i = M.transformNode(S.contents), t1 = I(C, i, M), s = t1.position, a2 = t1.documentEndPoint;
                            return (P = M.comments).push.apply(P, e.__spreadArrays(R, B)), {
                                documentBody: r.createDocumentBody(s, i, B),
                                documentEndPoint: a2,
                                documentTrailingComment: U,
                                documentHeadTrailingComment: f2
                            };
                        }
                        n.transformDocumentBody = y;
                        function E(S, M, T) {
                            for(var P = [], C = [], q = [], R = [], B = false, U = S.contents.length - 1; U >= 0; U--){
                                var f2 = S.contents[U];
                                if (f2.type === "COMMENT") {
                                    var i = M.transformNode(f2);
                                    T && T.line === i.position.start.line ? R.unshift(i) : B ? P.unshift(i) : i.position.start.offset >= S.valueRange.origEnd ? q.unshift(i) : P.unshift(i);
                                } else B = true;
                            }
                            if (q.length > 1) throw new Error("Unexpected multiple document trailing comments at " + d.getPointText(q[1].position.start));
                            if (R.length > 1) throw new Error("Unexpected multiple documentHead trailing comments at " + d.getPointText(R[1].position.start));
                            return {
                                comments: P,
                                endComments: C,
                                documentTrailingComment: c.getLast(q) || null,
                                documentHeadTrailingComment: c.getLast(R) || null
                            };
                        }
                        function I(S, M, T) {
                            var P = h.getMatchIndex(T.text.slice(S.valueRange.origEnd), /^\.\.\./), C = P === -1 ? S.valueRange.origEnd : Math.max(0, S.valueRange.origEnd - 1);
                            T.text[C - 1] === "\r" && C--;
                            var q = T.transformRange({
                                origStart: M !== null ? M.position.start.offset : C,
                                origEnd: C
                            }), R = P === -1 ? q.end : T.transformOffset(S.valueRange.origEnd + 3);
                            return {
                                position: q,
                                documentEndPoint: R
                            };
                        }
                    }
                }), dr = D({
                    "node_modules/yaml-unist-parser/lib/factories/document-head.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Ee(), c = me(), h = $e();
                        function d(y, E, I, S) {
                            return e.__assign(e.__assign(e.__assign(e.__assign({}, c.createNode("documentHead", y)), r.createEndCommentAttachable(I)), h.createTrailingCommentAttachable(S)), {
                                children: E
                            });
                        }
                        n.createDocumentHead = d;
                    }
                }), hr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/document-head.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = dr(), c = ze();
                        function h(E, I) {
                            var S, M = E.cstNode, T = d(M, I), P = T.directives, C = T.comments, q = T.endComments, R = y(M, P, I), B = R.position, U = R.endMarkerPoint;
                            (S = I.comments).push.apply(S, e.__spreadArrays(C, q));
                            var f2 = function(i) {
                                return i && I.comments.push(i), r.createDocumentHead(B, P, q, i);
                            };
                            return {
                                createDocumentHeadWithTrailingComment: f2,
                                documentHeadEndMarkerPoint: U
                            };
                        }
                        n.transformDocumentHead = h;
                        function d(E, I) {
                            for(var S = [], M = [], T = [], P = false, C = E.directives.length - 1; C >= 0; C--){
                                var q = I.transformNode(E.directives[C]);
                                q.type === "comment" ? P ? M.unshift(q) : T.unshift(q) : (P = true, S.unshift(q));
                            }
                            return {
                                directives: S,
                                comments: M,
                                endComments: T
                            };
                        }
                        function y(E, I, S) {
                            var M = c.getMatchIndex(S.text.slice(0, E.valueRange.origStart), /---\s*$/);
                            M > 0 && !/[\r\n]/.test(S.text[M - 1]) && (M = -1);
                            var T = M === -1 ? {
                                origStart: E.valueRange.origStart,
                                origEnd: E.valueRange.origStart
                            } : {
                                origStart: M,
                                origEnd: M + 3
                            };
                            return I.length !== 0 && (T.origStart = I[0].position.start.offset), {
                                position: S.transformRange(T),
                                endMarkerPoint: M === -1 ? null : S.transformOffset(M)
                            };
                        }
                    }
                }), gr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/document.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = ur(), r = Le(), c = mr(), h = hr();
                        function d(y, E) {
                            var I = h.transformDocumentHead(y, E), S = I.createDocumentHeadWithTrailingComment, M = I.documentHeadEndMarkerPoint, T = c.transformDocumentBody(y, E, M), P = T.documentBody, C = T.documentEndPoint, q = T.documentTrailingComment, R = T.documentHeadTrailingComment, B = S(R);
                            return q && E.comments.push(q), e.createDocument(r.createPosition(B.position.start, C), B, P, q);
                        }
                        n.transformDocument = d;
                    }
                }), Ze = D({
                    "node_modules/yaml-unist-parser/lib/factories/flow-collection.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Se(), c = Ee(), h = me();
                        function d(y, E, I) {
                            return e.__assign(e.__assign(e.__assign(e.__assign(e.__assign({}, h.createNode("flowCollection", y)), r.createCommentAttachable()), c.createEndCommentAttachable()), E), {
                                children: I
                            });
                        }
                        n.createFlowCollection = d;
                    }
                }), pr = D({
                    "node_modules/yaml-unist-parser/lib/factories/flow-mapping.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Ze();
                        function c(h, d, y) {
                            return e.__assign(e.__assign({}, r.createFlowCollection(h, d, y)), {
                                type: "flowMapping"
                            });
                        }
                        n.createFlowMapping = c;
                    }
                }), Xe = D({
                    "node_modules/yaml-unist-parser/lib/factories/flow-mapping-item.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Oe(), c = me();
                        function h(d, y, E) {
                            return e.__assign(e.__assign(e.__assign({}, c.createNode("flowMappingItem", d)), r.createLeadingCommentAttachable()), {
                                children: [
                                    y,
                                    E
                                ]
                            });
                        }
                        n.createFlowMappingItem = h;
                    }
                }), Be = D({
                    "node_modules/yaml-unist-parser/lib/utils/extract-comments.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r, c) {
                            for(var h = [], d = 0, y = r; d < y.length; d++){
                                var E = y[d];
                                E && "type" in E && E.type === "COMMENT" ? c.comments.push(c.transformNode(E)) : h.push(E);
                            }
                            return h;
                        }
                        n.extractComments = e;
                    }
                }), et = D({
                    "node_modules/yaml-unist-parser/lib/utils/get-flow-map-item-additional-ranges.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r) {
                            var c = [
                                "?",
                                ":"
                            ].map(function(y) {
                                var E = r.find(function(I) {
                                    return "char" in I && I.char === y;
                                });
                                return E ? {
                                    origStart: E.origOffset,
                                    origEnd: E.origOffset + 1
                                } : null;
                            }), h = c[0], d = c[1];
                            return {
                                additionalKeyRange: h,
                                additionalValueRange: d
                            };
                        }
                        n.getFlowMapItemAdditionalRanges = e;
                    }
                }), tt = D({
                    "node_modules/yaml-unist-parser/lib/utils/create-slicer.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r, c) {
                            var h = c;
                            return function(d) {
                                return r.slice(h, h = d);
                            };
                        }
                        n.createSlicer = e;
                    }
                }), rt = D({
                    "node_modules/yaml-unist-parser/lib/utils/group-cst-flow-collection-items.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = tt();
                        function r(c) {
                            for(var h = [], d = e.createSlicer(c, 1), y = false, E = 1; E < c.length - 1; E++){
                                var I = c[E];
                                if ("char" in I && I.char === ",") {
                                    h.push(d(E)), d(E + 1), y = false;
                                    continue;
                                }
                                y = true;
                            }
                            return y && h.push(d(c.length - 1)), h;
                        }
                        n.groupCstFlowCollectionItems = r;
                    }
                }), _r = D({
                    "node_modules/yaml-unist-parser/lib/factories/mapping-key.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Ee(), c = me(), h = $e();
                        function d(y, E) {
                            return e.__assign(e.__assign(e.__assign(e.__assign({}, c.createNode("mappingKey", y)), h.createTrailingCommentAttachable()), r.createEndCommentAttachable()), {
                                children: E ? [
                                    E
                                ] : []
                            });
                        }
                        n.createMappingKey = d;
                    }
                }), vr = D({
                    "node_modules/yaml-unist-parser/lib/factories/mapping-value.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Se(), c = Ee(), h = me();
                        function d(y, E) {
                            return e.__assign(e.__assign(e.__assign(e.__assign({}, h.createNode("mappingValue", y)), r.createCommentAttachable()), c.createEndCommentAttachable()), {
                                children: E ? [
                                    E
                                ] : []
                            });
                        }
                        n.createMappingValue = d;
                    }
                }), Qe = D({
                    "node_modules/yaml-unist-parser/lib/transforms/pair.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = _r(), r = vr(), c = Le();
                        function h(d, y, E, I, S) {
                            var M = y.transformNode(d.key), T = y.transformNode(d.value), P = M || I ? e.createMappingKey(y.transformRange({
                                origStart: I ? I.origStart : M.position.start.offset,
                                origEnd: M ? M.position.end.offset : I.origStart + 1
                            }), M) : null, C = T || S ? r.createMappingValue(y.transformRange({
                                origStart: S ? S.origStart : T.position.start.offset,
                                origEnd: T ? T.position.end.offset : S.origStart + 1
                            }), T) : null;
                            return E(c.createPosition(P ? P.position.start : C.position.start, C ? C.position.end : P.position.end), P || e.createMappingKey(c.createEmptyPosition(C.position.start), null), C || r.createMappingValue(c.createEmptyPosition(P.position.end), null));
                        }
                        n.transformAstPair = h;
                    }
                }), yr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/flow-map.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = pr(), r = Xe(), c = Be(), h = et(), d = Ae(), y = rt(), E = Qe();
                        function I(S, M) {
                            var T = c.extractComments(S.cstNode.items, M), P = y.groupCstFlowCollectionItems(T), C = S.items.map(function(B, U) {
                                var f2 = P[U], i = h.getFlowMapItemAdditionalRanges(f2), t1 = i.additionalKeyRange, s = i.additionalValueRange;
                                return E.transformAstPair(B, M, r.createFlowMappingItem, t1, s);
                            }), q = T[0], R = d.getLast(T);
                            return e.createFlowMapping(M.transformRange({
                                origStart: q.origOffset,
                                origEnd: R.origOffset + 1
                            }), M.transformContent(S), C);
                        }
                        n.transformFlowMap = I;
                    }
                }), br = D({
                    "node_modules/yaml-unist-parser/lib/factories/flow-sequence.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Ze();
                        function c(h, d, y) {
                            return e.__assign(e.__assign({}, r.createFlowCollection(h, d, y)), {
                                type: "flowSequence"
                            });
                        }
                        n.createFlowSequence = c;
                    }
                }), wr = D({
                    "node_modules/yaml-unist-parser/lib/factories/flow-sequence-item.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = me();
                        function c(h, d) {
                            return e.__assign(e.__assign({}, r.createNode("flowSequenceItem", h)), {
                                children: [
                                    d
                                ]
                            });
                        }
                        n.createFlowSequenceItem = c;
                    }
                }), Sr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/flow-seq.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Xe(), r = br(), c = wr(), h = Le(), d = Be(), y = et(), E = Ae(), I = rt(), S = Qe();
                        function M(T, P) {
                            var C = d.extractComments(T.cstNode.items, P), q = I.groupCstFlowCollectionItems(C), R = T.items.map(function(f2, i) {
                                if (f2.type !== "PAIR") {
                                    var t1 = P.transformNode(f2);
                                    return c.createFlowSequenceItem(h.createPosition(t1.position.start, t1.position.end), t1);
                                } else {
                                    var s = q[i], a2 = y.getFlowMapItemAdditionalRanges(s), m = a2.additionalKeyRange, g = a2.additionalValueRange;
                                    return S.transformAstPair(f2, P, e.createFlowMappingItem, m, g);
                                }
                            }), B = C[0], U = E.getLast(C);
                            return r.createFlowSequence(P.transformRange({
                                origStart: B.origOffset,
                                origEnd: U.origOffset + 1
                            }), P.transformContent(T), R);
                        }
                        n.transformFlowSeq = M;
                    }
                }), Er = D({
                    "node_modules/yaml-unist-parser/lib/factories/mapping.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Oe(), c = me();
                        function h(d, y, E) {
                            return e.__assign(e.__assign(e.__assign(e.__assign({}, c.createNode("mapping", d)), r.createLeadingCommentAttachable()), y), {
                                children: E
                            });
                        }
                        n.createMapping = h;
                    }
                }), Mr = D({
                    "node_modules/yaml-unist-parser/lib/factories/mapping-item.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Oe(), c = me();
                        function h(d, y, E) {
                            return e.__assign(e.__assign(e.__assign({}, c.createNode("mappingItem", d)), r.createLeadingCommentAttachable()), {
                                children: [
                                    y,
                                    E
                                ]
                            });
                        }
                        n.createMappingItem = h;
                    }
                }), Or = D({
                    "node_modules/yaml-unist-parser/lib/transforms/map.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Er(), r = Mr(), c = Le(), h = tt(), d = Be(), y = Ve(), E = Ae(), I = Qe();
                        function S(T, P) {
                            var C = T.cstNode;
                            C.items.filter(function(U) {
                                return U.type === "MAP_KEY" || U.type === "MAP_VALUE";
                            }).forEach(function(U) {
                                return y.extractPropComments(U, P);
                            });
                            var q = d.extractComments(C.items, P), R = M(q), B = T.items.map(function(U, f2) {
                                var i = R[f2], t1 = i[0].type === "MAP_VALUE" ? [
                                    null,
                                    i[0].range
                                ] : [
                                    i[0].range,
                                    i.length === 1 ? null : i[1].range
                                ], s = t1[0], a2 = t1[1];
                                return I.transformAstPair(U, P, r.createMappingItem, s, a2);
                            });
                            return e.createMapping(c.createPosition(B[0].position.start, E.getLast(B).position.end), P.transformContent(T), B);
                        }
                        n.transformMap = S;
                        function M(T) {
                            for(var P = [], C = h.createSlicer(T, 0), q = false, R = 0; R < T.length; R++){
                                var B = T[R];
                                if (B.type === "MAP_VALUE") {
                                    P.push(C(R + 1)), q = false;
                                    continue;
                                }
                                q && P.push(C(R)), q = true;
                            }
                            return q && P.push(C(1 / 0)), P;
                        }
                    }
                }), Lr = D({
                    "node_modules/yaml-unist-parser/lib/factories/plain.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Se(), c = me();
                        function h(d, y, E) {
                            return e.__assign(e.__assign(e.__assign(e.__assign({}, c.createNode("plain", d)), r.createCommentAttachable()), y), {
                                value: E
                            });
                        }
                        n.createPlain = h;
                    }
                }), Ar = D({
                    "node_modules/yaml-unist-parser/lib/utils/find-last-char-index.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r, c, h) {
                            for(var d = c; d >= 0; d--)if (h.test(r[d])) return d;
                            return -1;
                        }
                        n.findLastCharIndex = e;
                    }
                }), Nr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/plain.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Lr(), r = Ar();
                        function c(h, d) {
                            var y = h.cstNode;
                            return e.createPlain(d.transformRange({
                                origStart: y.valueRange.origStart,
                                origEnd: r.findLastCharIndex(d.text, y.valueRange.origEnd - 1, /\S/) + 1
                            }), d.transformContent(h), y.strValue);
                        }
                        n.transformPlain = c;
                    }
                }), Tr = D({
                    "node_modules/yaml-unist-parser/lib/factories/quote-double.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te));
                        function r(c) {
                            return e.__assign(e.__assign({}, c), {
                                type: "quoteDouble"
                            });
                        }
                        n.createQuoteDouble = r;
                    }
                }), Cr = D({
                    "node_modules/yaml-unist-parser/lib/factories/quote-value.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Se(), c = me();
                        function h(d, y, E) {
                            return e.__assign(e.__assign(e.__assign(e.__assign({}, c.createNode("quoteValue", d)), y), r.createCommentAttachable()), {
                                value: E
                            });
                        }
                        n.createQuoteValue = h;
                    }
                }), nt = D({
                    "node_modules/yaml-unist-parser/lib/transforms/quote-value.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Cr();
                        function r(c, h) {
                            var d = c.cstNode;
                            return e.createQuoteValue(h.transformRange(d.valueRange), h.transformContent(c), d.strValue);
                        }
                        n.transformAstQuoteValue = r;
                    }
                }), kr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/quote-double.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Tr(), r = nt();
                        function c(h, d) {
                            return e.createQuoteDouble(r.transformAstQuoteValue(h, d));
                        }
                        n.transformQuoteDouble = c;
                    }
                }), Pr = D({
                    "node_modules/yaml-unist-parser/lib/factories/quote-single.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te));
                        function r(c) {
                            return e.__assign(e.__assign({}, c), {
                                type: "quoteSingle"
                            });
                        }
                        n.createQuoteSingle = r;
                    }
                }), Ir = D({
                    "node_modules/yaml-unist-parser/lib/transforms/quote-single.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Pr(), r = nt();
                        function c(h, d) {
                            return e.createQuoteSingle(r.transformAstQuoteValue(h, d));
                        }
                        n.transformQuoteSingle = c;
                    }
                }), Rr = D({
                    "node_modules/yaml-unist-parser/lib/factories/sequence.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Ee(), c = Oe(), h = me();
                        function d(y, E, I) {
                            return e.__assign(e.__assign(e.__assign(e.__assign(e.__assign({}, h.createNode("sequence", y)), c.createLeadingCommentAttachable()), r.createEndCommentAttachable()), E), {
                                children: I
                            });
                        }
                        n.createSequence = d;
                    }
                }), qr = D({
                    "node_modules/yaml-unist-parser/lib/factories/sequence-item.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te)), r = Se(), c = Ee(), h = me();
                        function d(y, E) {
                            return e.__assign(e.__assign(e.__assign(e.__assign({}, h.createNode("sequenceItem", y)), r.createCommentAttachable()), c.createEndCommentAttachable()), {
                                children: E ? [
                                    E
                                ] : []
                            });
                        }
                        n.createSequenceItem = d;
                    }
                }), $r = D({
                    "node_modules/yaml-unist-parser/lib/transforms/seq.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Le(), r = Rr(), c = qr(), h = Be(), d = Ve(), y = Ae();
                        function E(I, S) {
                            var M = h.extractComments(I.cstNode.items, S), T = M.map(function(P, C) {
                                d.extractPropComments(P, S);
                                var q = S.transformNode(I.items[C]);
                                return c.createSequenceItem(e.createPosition(S.transformOffset(P.valueRange.origStart), q === null ? S.transformOffset(P.valueRange.origStart + 1) : q.position.end), q);
                            });
                            return r.createSequence(e.createPosition(T[0].position.start, y.getLast(T).position.end), S.transformContent(I), T);
                        }
                        n.transformSeq = E;
                    }
                }), Br = D({
                    "node_modules/yaml-unist-parser/lib/transform.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Zt(), r = sr(), c = ar(), h = or(), d = cr(), y = gr(), E = yr(), I = Sr(), S = Or(), M = Nr(), T = kr(), P = Ir(), C = $r();
                        function q(R, B) {
                            if (R === null || R.type === void 0 && R.value === null) return null;
                            switch(R.type){
                                case "ALIAS":
                                    return e.transformAlias(R, B);
                                case "BLOCK_FOLDED":
                                    return r.transformBlockFolded(R, B);
                                case "BLOCK_LITERAL":
                                    return c.transformBlockLiteral(R, B);
                                case "COMMENT":
                                    return h.transformComment(R, B);
                                case "DIRECTIVE":
                                    return d.transformDirective(R, B);
                                case "DOCUMENT":
                                    return y.transformDocument(R, B);
                                case "FLOW_MAP":
                                    return E.transformFlowMap(R, B);
                                case "FLOW_SEQ":
                                    return I.transformFlowSeq(R, B);
                                case "MAP":
                                    return S.transformMap(R, B);
                                case "PLAIN":
                                    return M.transformPlain(R, B);
                                case "QUOTE_DOUBLE":
                                    return T.transformQuoteDouble(R, B);
                                case "QUOTE_SINGLE":
                                    return P.transformQuoteSingle(R, B);
                                case "SEQ":
                                    return C.transformSeq(R, B);
                                default:
                                    throw new Error("Unexpected node type " + R.type);
                            }
                        }
                        n.transformNode = q;
                    }
                }), jr = D({
                    "node_modules/yaml-unist-parser/lib/factories/error.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r, c, h) {
                            var d = new SyntaxError(r);
                            return d.name = "YAMLSyntaxError", d.source = c, d.position = h, d;
                        }
                        n.createError = e;
                    }
                }), Yr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/error.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = jr();
                        function r(c, h) {
                            var d = c.source.range || c.source.valueRange;
                            return e.createError(c.message, h.text, h.transformRange(d));
                        }
                        n.transformError = r;
                    }
                }), Dr = D({
                    "node_modules/yaml-unist-parser/lib/factories/point.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r, c, h) {
                            return {
                                offset: r,
                                line: c,
                                column: h
                            };
                        }
                        n.createPoint = e;
                    }
                }), Fr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/offset.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Dr();
                        function r(c, h) {
                            c < 0 ? c = 0 : c > h.text.length && (c = h.text.length);
                            var d = h.locator.locationForIndex(c);
                            return e.createPoint(c, d.line + 1, d.column + 1);
                        }
                        n.transformOffset = r;
                    }
                }), Wr = D({
                    "node_modules/yaml-unist-parser/lib/transforms/range.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Le();
                        function r(c, h) {
                            return e.createPosition(h.transformOffset(c.origStart), h.transformOffset(c.origEnd));
                        }
                        n.transformRange = r;
                    }
                }), Vr = D({
                    "node_modules/yaml-unist-parser/lib/utils/add-orig-range.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = true;
                        function r(y) {
                            if (!y.setOrigRanges()) {
                                var E = function(I) {
                                    if (h(I)) return I.origStart = I.start, I.origEnd = I.end, e;
                                    if (d(I)) return I.origOffset = I.offset, e;
                                };
                                y.forEach(function(I) {
                                    return c(I, E);
                                });
                            }
                        }
                        n.addOrigRange = r;
                        function c(y, E) {
                            if (!(!y || typeof y != "object") && E(y) !== e) for(var I = 0, S = Object.keys(y); I < S.length; I++){
                                var M = S[I];
                                if (!(M === "context" || M === "error")) {
                                    var T = y[M];
                                    Array.isArray(T) ? T.forEach(function(P) {
                                        return c(P, E);
                                    }) : c(T, E);
                                }
                            }
                        }
                        function h(y) {
                            return typeof y.start == "number";
                        }
                        function d(y) {
                            return typeof y.offset == "number";
                        }
                    }
                }), Qr = D({
                    "node_modules/yaml-unist-parser/lib/utils/remove-fake-nodes.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r) {
                            if ("children" in r) {
                                if (r.children.length === 1) {
                                    var c = r.children[0];
                                    if (c.type === "plain" && c.tag === null && c.anchor === null && c.value === "") return r.children.splice(0, 1), r;
                                }
                                r.children.forEach(e);
                            }
                            return r;
                        }
                        n.removeFakeNodes = e;
                    }
                }), Ur = D({
                    "node_modules/yaml-unist-parser/lib/utils/create-updater.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        function e(r, c, h, d) {
                            var y = c(r);
                            return function(E) {
                                d(y, E) && h(r, y = E);
                            };
                        }
                        n.createUpdater = e;
                    }
                }), Kr = D({
                    "node_modules/yaml-unist-parser/lib/utils/update-positions.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Ur(), r = Ae();
                        function c(M) {
                            if (!(M === null || !("children" in M))) {
                                var T = M.children;
                                if (T.forEach(c), M.type === "document") {
                                    var P = M.children, C = P[0], q = P[1];
                                    C.position.start.offset === C.position.end.offset ? C.position.start = C.position.end = q.position.start : q.position.start.offset === q.position.end.offset && (q.position.start = q.position.end = C.position.end);
                                }
                                var R = e.createUpdater(M.position, h, d, I), B = e.createUpdater(M.position, y, E, S);
                                "endComments" in M && M.endComments.length !== 0 && (R(M.endComments[0].position.start), B(r.getLast(M.endComments).position.end));
                                var U = T.filter(function(t1) {
                                    return t1 !== null;
                                });
                                if (U.length !== 0) {
                                    var f2 = U[0], i = r.getLast(U);
                                    R(f2.position.start), B(i.position.end), "leadingComments" in f2 && f2.leadingComments.length !== 0 && R(f2.leadingComments[0].position.start), "tag" in f2 && f2.tag && R(f2.tag.position.start), "anchor" in f2 && f2.anchor && R(f2.anchor.position.start), "trailingComment" in i && i.trailingComment && B(i.trailingComment.position.end);
                                }
                            }
                        }
                        n.updatePositions = c;
                        function h(M) {
                            return M.start;
                        }
                        function d(M, T) {
                            M.start = T;
                        }
                        function y(M) {
                            return M.end;
                        }
                        function E(M, T) {
                            M.end = T;
                        }
                        function I(M, T) {
                            return T.offset < M.offset;
                        }
                        function S(M, T) {
                            return T.offset > M.offset;
                        }
                    }
                }), Me = D({
                    "node_modules/yaml/dist/PlainValue-ec8e588e.js" (n) {
                        "use strict";
                        Y();
                        var e = {
                            ANCHOR: "&",
                            COMMENT: "#",
                            TAG: "!",
                            DIRECTIVES_END: "-",
                            DOCUMENT_END: "."
                        }, r = {
                            ALIAS: "ALIAS",
                            BLANK_LINE: "BLANK_LINE",
                            BLOCK_FOLDED: "BLOCK_FOLDED",
                            BLOCK_LITERAL: "BLOCK_LITERAL",
                            COMMENT: "COMMENT",
                            DIRECTIVE: "DIRECTIVE",
                            DOCUMENT: "DOCUMENT",
                            FLOW_MAP: "FLOW_MAP",
                            FLOW_SEQ: "FLOW_SEQ",
                            MAP: "MAP",
                            MAP_KEY: "MAP_KEY",
                            MAP_VALUE: "MAP_VALUE",
                            PLAIN: "PLAIN",
                            QUOTE_DOUBLE: "QUOTE_DOUBLE",
                            QUOTE_SINGLE: "QUOTE_SINGLE",
                            SEQ: "SEQ",
                            SEQ_ITEM: "SEQ_ITEM"
                        }, c = "tag:yaml.org,2002:", h = {
                            MAP: "tag:yaml.org,2002:map",
                            SEQ: "tag:yaml.org,2002:seq",
                            STR: "tag:yaml.org,2002:str"
                        };
                        function d(i) {
                            let t1 = [
                                0
                            ], s = i.indexOf(`
`);
                            for(; s !== -1;)s += 1, t1.push(s), s = i.indexOf(`
`, s);
                            return t1;
                        }
                        function y(i) {
                            let t1, s;
                            return typeof i == "string" ? (t1 = d(i), s = i) : (Array.isArray(i) && (i = i[0]), i && i.context && (i.lineStarts || (i.lineStarts = d(i.context.src)), t1 = i.lineStarts, s = i.context.src)), {
                                lineStarts: t1,
                                src: s
                            };
                        }
                        function E(i, t1) {
                            if (typeof i != "number" || i < 0) return null;
                            let { lineStarts: s, src: a2 } = y(t1);
                            if (!s || !a2 || i > a2.length) return null;
                            for(let g = 0; g < s.length; ++g){
                                let u = s[g];
                                if (i < u) return {
                                    line: g,
                                    col: i - s[g - 1] + 1
                                };
                                if (i === u) return {
                                    line: g + 1,
                                    col: 1
                                };
                            }
                            let m = s.length;
                            return {
                                line: m,
                                col: i - s[m - 1] + 1
                            };
                        }
                        function I(i, t1) {
                            let { lineStarts: s, src: a2 } = y(t1);
                            if (!s || !(i >= 1) || i > s.length) return null;
                            let m = s[i - 1], g = s[i];
                            for(; g && g > m && a2[g - 1] === `
`;)--g;
                            return a2.slice(m, g);
                        }
                        function S(i, t1) {
                            let { start: s, end: a2 } = i, m = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 80, g = I(s.line, t1);
                            if (!g) return null;
                            let { col: u } = s;
                            if (g.length > m) if (u <= m - 10) g = g.substr(0, m - 1) + "\u2026";
                            else {
                                let K = Math.round(m / 2);
                                g.length > u + K && (g = g.substr(0, u + K - 1) + "\u2026"), u -= g.length - m, g = "\u2026" + g.substr(1 - m);
                            }
                            let p = 1, L = "";
                            a2 && (a2.line === s.line && u + (a2.col - s.col) <= m + 1 ? p = a2.col - s.col : (p = Math.min(g.length + 1, m) - u, L = "\u2026"));
                            let k = u > 1 ? " ".repeat(u - 1) : "", $ = "^".repeat(p);
                            return `${g}
${k}${$}${L}`;
                        }
                        var M = class {
                            static copy(i) {
                                return new M(i.start, i.end);
                            }
                            isEmpty() {
                                return typeof this.start != "number" || !this.end || this.end <= this.start;
                            }
                            setOrigRange(i, t1) {
                                let { start: s, end: a2 } = this;
                                if (i.length === 0 || a2 <= i[0]) return this.origStart = s, this.origEnd = a2, t1;
                                let m = t1;
                                for(; m < i.length && !(i[m] > s);)++m;
                                this.origStart = s + m;
                                let g = m;
                                for(; m < i.length && !(i[m] >= a2);)++m;
                                return this.origEnd = a2 + m, g;
                            }
                            constructor(i, t1){
                                this.start = i, this.end = t1 || i;
                            }
                        }, T = class {
                            static addStringTerminator(i, t1, s) {
                                if (s[s.length - 1] === `
`) return s;
                                let a2 = T.endOfWhiteSpace(i, t1);
                                return a2 >= i.length || i[a2] === `
` ? s + `
` : s;
                            }
                            static atDocumentBoundary(i, t1, s) {
                                let a2 = i[t1];
                                if (!a2) return true;
                                let m = i[t1 - 1];
                                if (m && m !== `
`) return false;
                                if (s) {
                                    if (a2 !== s) return false;
                                } else if (a2 !== e.DIRECTIVES_END && a2 !== e.DOCUMENT_END) return false;
                                let g = i[t1 + 1], u = i[t1 + 2];
                                if (g !== a2 || u !== a2) return false;
                                let p = i[t1 + 3];
                                return !p || p === `
` || p === "	" || p === " ";
                            }
                            static endOfIdentifier(i, t1) {
                                let s = i[t1], a2 = s === "<", m = a2 ? [
                                    `
`,
                                    "	",
                                    " ",
                                    ">"
                                ] : [
                                    `
`,
                                    "	",
                                    " ",
                                    "[",
                                    "]",
                                    "{",
                                    "}",
                                    ","
                                ];
                                for(; s && m.indexOf(s) === -1;)s = i[t1 += 1];
                                return a2 && s === ">" && (t1 += 1), t1;
                            }
                            static endOfIndent(i, t1) {
                                let s = i[t1];
                                for(; s === " ";)s = i[t1 += 1];
                                return t1;
                            }
                            static endOfLine(i, t1) {
                                let s = i[t1];
                                for(; s && s !== `
`;)s = i[t1 += 1];
                                return t1;
                            }
                            static endOfWhiteSpace(i, t1) {
                                let s = i[t1];
                                for(; s === "	" || s === " ";)s = i[t1 += 1];
                                return t1;
                            }
                            static startOfLine(i, t1) {
                                let s = i[t1 - 1];
                                if (s === `
`) return t1;
                                for(; s && s !== `
`;)s = i[t1 -= 1];
                                return t1 + 1;
                            }
                            static endOfBlockIndent(i, t1, s) {
                                let a2 = T.endOfIndent(i, s);
                                if (a2 > s + t1) return a2;
                                {
                                    let m = T.endOfWhiteSpace(i, a2), g = i[m];
                                    if (!g || g === `
`) return m;
                                }
                                return null;
                            }
                            static atBlank(i, t1, s) {
                                let a2 = i[t1];
                                return a2 === `
` || a2 === "	" || a2 === " " || s && !a2;
                            }
                            static nextNodeIsIndented(i, t1, s) {
                                return !i || t1 < 0 ? false : t1 > 0 ? true : s && i === "-";
                            }
                            static normalizeOffset(i, t1) {
                                let s = i[t1];
                                return s ? s !== `
` && i[t1 - 1] === `
` ? t1 - 1 : T.endOfWhiteSpace(i, t1) : t1;
                            }
                            static foldNewline(i, t1, s) {
                                let a2 = 0, m = false, g = "", u = i[t1 + 1];
                                for(; u === " " || u === "	" || u === `
`;){
                                    switch(u){
                                        case `
`:
                                            a2 = 0, t1 += 1, g += `
`;
                                            break;
                                        case "	":
                                            a2 <= s && (m = true), t1 = T.endOfWhiteSpace(i, t1 + 2) - 1;
                                            break;
                                        case " ":
                                            a2 += 1, t1 += 1;
                                            break;
                                    }
                                    u = i[t1 + 1];
                                }
                                return g || (g = " "), u && a2 <= s && (m = true), {
                                    fold: g,
                                    offset: t1,
                                    error: m
                                };
                            }
                            getPropValue(i, t1, s) {
                                if (!this.context) return null;
                                let { src: a2 } = this.context, m = this.props[i];
                                return m && a2[m.start] === t1 ? a2.slice(m.start + (s ? 1 : 0), m.end) : null;
                            }
                            get anchor() {
                                for(let i = 0; i < this.props.length; ++i){
                                    let t1 = this.getPropValue(i, e.ANCHOR, true);
                                    if (t1 != null) return t1;
                                }
                                return null;
                            }
                            get comment() {
                                let i = [];
                                for(let t1 = 0; t1 < this.props.length; ++t1){
                                    let s = this.getPropValue(t1, e.COMMENT, true);
                                    s != null && i.push(s);
                                }
                                return i.length > 0 ? i.join(`
`) : null;
                            }
                            commentHasRequiredWhitespace(i) {
                                let { src: t1 } = this.context;
                                if (this.header && i === this.header.end || !this.valueRange) return false;
                                let { end: s } = this.valueRange;
                                return i !== s || T.atBlank(t1, s - 1);
                            }
                            get hasComment() {
                                if (this.context) {
                                    let { src: i } = this.context;
                                    for(let t1 = 0; t1 < this.props.length; ++t1)if (i[this.props[t1].start] === e.COMMENT) return true;
                                }
                                return false;
                            }
                            get hasProps() {
                                if (this.context) {
                                    let { src: i } = this.context;
                                    for(let t1 = 0; t1 < this.props.length; ++t1)if (i[this.props[t1].start] !== e.COMMENT) return true;
                                }
                                return false;
                            }
                            get includesTrailingLines() {
                                return false;
                            }
                            get jsonLike() {
                                return [
                                    r.FLOW_MAP,
                                    r.FLOW_SEQ,
                                    r.QUOTE_DOUBLE,
                                    r.QUOTE_SINGLE
                                ].indexOf(this.type) !== -1;
                            }
                            get rangeAsLinePos() {
                                if (!this.range || !this.context) return;
                                let i = E(this.range.start, this.context.root);
                                if (!i) return;
                                let t1 = E(this.range.end, this.context.root);
                                return {
                                    start: i,
                                    end: t1
                                };
                            }
                            get rawValue() {
                                if (!this.valueRange || !this.context) return null;
                                let { start: i, end: t1 } = this.valueRange;
                                return this.context.src.slice(i, t1);
                            }
                            get tag() {
                                for(let i = 0; i < this.props.length; ++i){
                                    let t1 = this.getPropValue(i, e.TAG, false);
                                    if (t1 != null) {
                                        if (t1[1] === "<") return {
                                            verbatim: t1.slice(2, -1)
                                        };
                                        {
                                            let [s, a2, m] = t1.match(/^(.*!)([^!]*)$/);
                                            return {
                                                handle: a2,
                                                suffix: m
                                            };
                                        }
                                    }
                                }
                                return null;
                            }
                            get valueRangeContainsNewline() {
                                if (!this.valueRange || !this.context) return false;
                                let { start: i, end: t1 } = this.valueRange, { src: s } = this.context;
                                for(let a2 = i; a2 < t1; ++a2)if (s[a2] === `
`) return true;
                                return false;
                            }
                            parseComment(i) {
                                let { src: t1 } = this.context;
                                if (t1[i] === e.COMMENT) {
                                    let s = T.endOfLine(t1, i + 1), a2 = new M(i, s);
                                    return this.props.push(a2), s;
                                }
                                return i;
                            }
                            setOrigRanges(i, t1) {
                                return this.range && (t1 = this.range.setOrigRange(i, t1)), this.valueRange && this.valueRange.setOrigRange(i, t1), this.props.forEach((s)=>s.setOrigRange(i, t1)), t1;
                            }
                            toString() {
                                let { context: { src: i }, range: t1, value: s } = this;
                                if (s != null) return s;
                                let a2 = i.slice(t1.start, t1.end);
                                return T.addStringTerminator(i, t1.end, a2);
                            }
                            constructor(i, t1, s){
                                Object.defineProperty(this, "context", {
                                    value: s || null,
                                    writable: true
                                }), this.error = null, this.range = null, this.valueRange = null, this.props = t1 || [], this.type = i, this.value = null;
                            }
                        }, P = class extends Error {
                            makePretty() {
                                if (!this.source) return;
                                this.nodeType = this.source.type;
                                let i = this.source.context && this.source.context.root;
                                if (typeof this.offset == "number") {
                                    this.range = new M(this.offset, this.offset + 1);
                                    let t1 = i && E(this.offset, i);
                                    if (t1) {
                                        let s = {
                                            line: t1.line,
                                            col: t1.col + 1
                                        };
                                        this.linePos = {
                                            start: t1,
                                            end: s
                                        };
                                    }
                                    delete this.offset;
                                } else this.range = this.source.range, this.linePos = this.source.rangeAsLinePos;
                                if (this.linePos) {
                                    let { line: t1, col: s } = this.linePos.start;
                                    this.message += ` at line ${t1}, column ${s}`;
                                    let a2 = i && S(this.linePos, i);
                                    a2 && (this.message += `:

${a2}
`);
                                }
                                delete this.source;
                            }
                            constructor(i, t1, s){
                                if (!s || !(t1 instanceof T)) throw new Error(`Invalid arguments for new ${i}`);
                                super(), this.name = i, this.message = s, this.source = t1;
                            }
                        }, C = class extends P {
                            constructor(i, t1){
                                super("YAMLReferenceError", i, t1);
                            }
                        }, q = class extends P {
                            constructor(i, t1){
                                super("YAMLSemanticError", i, t1);
                            }
                        }, R = class extends P {
                            constructor(i, t1){
                                super("YAMLSyntaxError", i, t1);
                            }
                        }, B = class extends P {
                            constructor(i, t1){
                                super("YAMLWarning", i, t1);
                            }
                        };
                        function U(i, t1, s) {
                            return t1 in i ? Object.defineProperty(i, t1, {
                                value: s,
                                enumerable: true,
                                configurable: true,
                                writable: true
                            }) : i[t1] = s, i;
                        }
                        var f2 = class extends T {
                            static endOfLine(i, t1, s) {
                                let a2 = i[t1], m = t1;
                                for(; a2 && a2 !== `
` && !(s && (a2 === "[" || a2 === "]" || a2 === "{" || a2 === "}" || a2 === ","));){
                                    let g = i[m + 1];
                                    if (a2 === ":" && (!g || g === `
` || g === "	" || g === " " || s && g === ",") || (a2 === " " || a2 === "	") && g === "#") break;
                                    m += 1, a2 = g;
                                }
                                return m;
                            }
                            get strValue() {
                                if (!this.valueRange || !this.context) return null;
                                let { start: i, end: t1 } = this.valueRange, { src: s } = this.context, a2 = s[t1 - 1];
                                for(; i < t1 && (a2 === `
` || a2 === "	" || a2 === " ");)a2 = s[--t1 - 1];
                                let m = "";
                                for(let u = i; u < t1; ++u){
                                    let p = s[u];
                                    if (p === `
`) {
                                        let { fold: L, offset: k } = T.foldNewline(s, u, -1);
                                        m += L, u = k;
                                    } else if (p === " " || p === "	") {
                                        let L = u, k = s[u + 1];
                                        for(; u < t1 && (k === " " || k === "	");)u += 1, k = s[u + 1];
                                        k !== `
` && (m += u > L ? s.slice(L, u + 1) : p);
                                    } else m += p;
                                }
                                let g = s[i];
                                switch(g){
                                    case "	":
                                        {
                                            let u = "Plain value cannot start with a tab character";
                                            return {
                                                errors: [
                                                    new q(this, u)
                                                ],
                                                str: m
                                            };
                                        }
                                    case "@":
                                    case "`":
                                        {
                                            let u = `Plain value cannot start with reserved character ${g}`;
                                            return {
                                                errors: [
                                                    new q(this, u)
                                                ],
                                                str: m
                                            };
                                        }
                                    default:
                                        return m;
                                }
                            }
                            parseBlockValue(i) {
                                let { indent: t1, inFlow: s, src: a2 } = this.context, m = i, g = i;
                                for(let u = a2[m]; u === `
` && !T.atDocumentBoundary(a2, m + 1); u = a2[m]){
                                    let p = T.endOfBlockIndent(a2, t1, m + 1);
                                    if (p === null || a2[p] === "#") break;
                                    a2[p] === `
` ? m = p : (g = f2.endOfLine(a2, p, s), m = g);
                                }
                                return this.valueRange.isEmpty() && (this.valueRange.start = i), this.valueRange.end = g, g;
                            }
                            parse(i, t1) {
                                this.context = i;
                                let { inFlow: s, src: a2 } = i, m = t1, g = a2[m];
                                return g && g !== "#" && g !== `
` && (m = f2.endOfLine(a2, t1, s)), this.valueRange = new M(t1, m), m = T.endOfWhiteSpace(a2, m), m = this.parseComment(m), (!this.hasComment || this.valueRange.isEmpty()) && (m = this.parseBlockValue(m)), m;
                            }
                        };
                        n.Char = e, n.Node = T, n.PlainValue = f2, n.Range = M, n.Type = r, n.YAMLError = P, n.YAMLReferenceError = C, n.YAMLSemanticError = q, n.YAMLSyntaxError = R, n.YAMLWarning = B, n._defineProperty = U, n.defaultTagPrefix = c, n.defaultTags = h;
                    }
                }), Jr = D({
                    "node_modules/yaml/dist/parse-cst.js" (n) {
                        "use strict";
                        Y();
                        var e = Me(), r = class extends e.Node {
                            get includesTrailingLines() {
                                return true;
                            }
                            parse(f2, i) {
                                return this.context = f2, this.range = new e.Range(i, i + 1), i + 1;
                            }
                            constructor(){
                                super(e.Type.BLANK_LINE);
                            }
                        }, c = class extends e.Node {
                            get includesTrailingLines() {
                                return !!this.node && this.node.includesTrailingLines;
                            }
                            parse(f2, i) {
                                this.context = f2;
                                let { parseNode: t1, src: s } = f2, { atLineStart: a2, lineStart: m } = f2;
                                !a2 && this.type === e.Type.SEQ_ITEM && (this.error = new e.YAMLSemanticError(this, "Sequence items must not have preceding content on the same line"));
                                let g = a2 ? i - m : f2.indent, u = e.Node.endOfWhiteSpace(s, i + 1), p = s[u], L = p === "#", k = [], $ = null;
                                for(; p === `
` || p === "#";){
                                    if (p === "#") {
                                        let V = e.Node.endOfLine(s, u + 1);
                                        k.push(new e.Range(u, V)), u = V;
                                    } else {
                                        a2 = true, m = u + 1;
                                        let V = e.Node.endOfWhiteSpace(s, m);
                                        s[V] === `
` && k.length === 0 && ($ = new r(), m = $.parse({
                                            src: s
                                        }, m)), u = e.Node.endOfIndent(s, m);
                                    }
                                    p = s[u];
                                }
                                if (e.Node.nextNodeIsIndented(p, u - (m + g), this.type !== e.Type.SEQ_ITEM) ? this.node = t1({
                                    atLineStart: a2,
                                    inCollection: false,
                                    indent: g,
                                    lineStart: m,
                                    parent: this
                                }, u) : p && m > i + 1 && (u = m - 1), this.node) {
                                    if ($) {
                                        let V = f2.parent.items || f2.parent.contents;
                                        V && V.push($);
                                    }
                                    k.length && Array.prototype.push.apply(this.props, k), u = this.node.range.end;
                                } else if (L) {
                                    let V = k[0];
                                    this.props.push(V), u = V.end;
                                } else u = e.Node.endOfLine(s, i + 1);
                                let K = this.node ? this.node.valueRange.end : u;
                                return this.valueRange = new e.Range(i, K), u;
                            }
                            setOrigRanges(f2, i) {
                                return i = super.setOrigRanges(f2, i), this.node ? this.node.setOrigRanges(f2, i) : i;
                            }
                            toString() {
                                let { context: { src: f2 }, node: i, range: t1, value: s } = this;
                                if (s != null) return s;
                                let a2 = i ? f2.slice(t1.start, i.range.start) + String(i) : f2.slice(t1.start, t1.end);
                                return e.Node.addStringTerminator(f2, t1.end, a2);
                            }
                            constructor(f2, i){
                                super(f2, i), this.node = null;
                            }
                        }, h = class extends e.Node {
                            parse(f2, i) {
                                this.context = f2;
                                let t1 = this.parseComment(i);
                                return this.range = new e.Range(i, t1), t1;
                            }
                            constructor(){
                                super(e.Type.COMMENT);
                            }
                        };
                        function d(f2) {
                            let i = f2;
                            for(; i instanceof c;)i = i.node;
                            if (!(i instanceof y)) return null;
                            let t1 = i.items.length, s = -1;
                            for(let g = t1 - 1; g >= 0; --g){
                                let u = i.items[g];
                                if (u.type === e.Type.COMMENT) {
                                    let { indent: p, lineStart: L } = u.context;
                                    if (p > 0 && u.range.start >= L + p) break;
                                    s = g;
                                } else if (u.type === e.Type.BLANK_LINE) s = g;
                                else break;
                            }
                            if (s === -1) return null;
                            let a2 = i.items.splice(s, t1 - s), m = a2[0].range.start;
                            for(; i.range.end = m, i.valueRange && i.valueRange.end > m && (i.valueRange.end = m), i !== f2;)i = i.context.parent;
                            return a2;
                        }
                        var y = class extends e.Node {
                            static nextContentHasIndent(f2, i, t1) {
                                let s = e.Node.endOfLine(f2, i) + 1;
                                i = e.Node.endOfWhiteSpace(f2, s);
                                let a2 = f2[i];
                                return a2 ? i >= s + t1 ? true : a2 !== "#" && a2 !== `
` ? false : y.nextContentHasIndent(f2, i, t1) : false;
                            }
                            get includesTrailingLines() {
                                return this.items.length > 0;
                            }
                            parse(f2, i) {
                                this.context = f2;
                                let { parseNode: t1, src: s } = f2, a2 = e.Node.startOfLine(s, i), m = this.items[0];
                                m.context.parent = this, this.valueRange = e.Range.copy(m.valueRange);
                                let g = m.range.start - m.context.lineStart, u = i;
                                u = e.Node.normalizeOffset(s, u);
                                let p = s[u], L = e.Node.endOfWhiteSpace(s, a2) === u, k = false;
                                for(; p;){
                                    for(; p === `
` || p === "#";){
                                        if (L && p === `
` && !k) {
                                            let V = new r();
                                            if (u = V.parse({
                                                src: s
                                            }, u), this.valueRange.end = u, u >= s.length) {
                                                p = null;
                                                break;
                                            }
                                            this.items.push(V), u -= 1;
                                        } else if (p === "#") {
                                            if (u < a2 + g && !y.nextContentHasIndent(s, u, g)) return u;
                                            let V = new h();
                                            if (u = V.parse({
                                                indent: g,
                                                lineStart: a2,
                                                src: s
                                            }, u), this.items.push(V), this.valueRange.end = u, u >= s.length) {
                                                p = null;
                                                break;
                                            }
                                        }
                                        if (a2 = u + 1, u = e.Node.endOfIndent(s, a2), e.Node.atBlank(s, u)) {
                                            let V = e.Node.endOfWhiteSpace(s, u), z = s[V];
                                            (!z || z === `
` || z === "#") && (u = V);
                                        }
                                        p = s[u], L = true;
                                    }
                                    if (!p) break;
                                    if (u !== a2 + g && (L || p !== ":")) {
                                        if (u < a2 + g) {
                                            a2 > i && (u = a2);
                                            break;
                                        } else if (!this.error) {
                                            let V = "All collection items must start at the same column";
                                            this.error = new e.YAMLSyntaxError(this, V);
                                        }
                                    }
                                    if (m.type === e.Type.SEQ_ITEM) {
                                        if (p !== "-") {
                                            a2 > i && (u = a2);
                                            break;
                                        }
                                    } else if (p === "-" && !this.error) {
                                        let V = s[u + 1];
                                        if (!V || V === `
` || V === "	" || V === " ") {
                                            let z = "A collection cannot be both a mapping and a sequence";
                                            this.error = new e.YAMLSyntaxError(this, z);
                                        }
                                    }
                                    let $ = t1({
                                        atLineStart: L,
                                        inCollection: true,
                                        indent: g,
                                        lineStart: a2,
                                        parent: this
                                    }, u);
                                    if (!$) return u;
                                    if (this.items.push($), this.valueRange.end = $.valueRange.end, u = e.Node.normalizeOffset(s, $.range.end), p = s[u], L = false, k = $.includesTrailingLines, p) {
                                        let V = u - 1, z = s[V];
                                        for(; z === " " || z === "	";)z = s[--V];
                                        z === `
` && (a2 = V + 1, L = true);
                                    }
                                    let K = d($);
                                    K && Array.prototype.push.apply(this.items, K);
                                }
                                return u;
                            }
                            setOrigRanges(f2, i) {
                                return i = super.setOrigRanges(f2, i), this.items.forEach((t1)=>{
                                    i = t1.setOrigRanges(f2, i);
                                }), i;
                            }
                            toString() {
                                let { context: { src: f2 }, items: i, range: t1, value: s } = this;
                                if (s != null) return s;
                                let a2 = f2.slice(t1.start, i[0].range.start) + String(i[0]);
                                for(let m = 1; m < i.length; ++m){
                                    let g = i[m], { atLineStart: u, indent: p } = g.context;
                                    if (u) for(let L = 0; L < p; ++L)a2 += " ";
                                    a2 += String(g);
                                }
                                return e.Node.addStringTerminator(f2, t1.end, a2);
                            }
                            constructor(f2){
                                super(f2.type === e.Type.SEQ_ITEM ? e.Type.SEQ : e.Type.MAP);
                                for(let t1 = f2.props.length - 1; t1 >= 0; --t1)if (f2.props[t1].start < f2.context.lineStart) {
                                    this.props = f2.props.slice(0, t1 + 1), f2.props = f2.props.slice(t1 + 1);
                                    let s = f2.props[0] || f2.valueRange;
                                    f2.range.start = s.start;
                                    break;
                                }
                                this.items = [
                                    f2
                                ];
                                let i = d(f2);
                                i && Array.prototype.push.apply(this.items, i);
                            }
                        }, E = class extends e.Node {
                            get parameters() {
                                let f2 = this.rawValue;
                                return f2 ? f2.trim().split(/[ \t]+/) : [];
                            }
                            parseName(f2) {
                                let { src: i } = this.context, t1 = f2, s = i[t1];
                                for(; s && s !== `
` && s !== "	" && s !== " ";)s = i[t1 += 1];
                                return this.name = i.slice(f2, t1), t1;
                            }
                            parseParameters(f2) {
                                let { src: i } = this.context, t1 = f2, s = i[t1];
                                for(; s && s !== `
` && s !== "#";)s = i[t1 += 1];
                                return this.valueRange = new e.Range(f2, t1), t1;
                            }
                            parse(f2, i) {
                                this.context = f2;
                                let t1 = this.parseName(i + 1);
                                return t1 = this.parseParameters(t1), t1 = this.parseComment(t1), this.range = new e.Range(i, t1), t1;
                            }
                            constructor(){
                                super(e.Type.DIRECTIVE), this.name = null;
                            }
                        }, I = class extends e.Node {
                            static startCommentOrEndBlankLine(f2, i) {
                                let t1 = e.Node.endOfWhiteSpace(f2, i), s = f2[t1];
                                return s === "#" || s === `
` ? t1 : i;
                            }
                            parseDirectives(f2) {
                                let { src: i } = this.context;
                                this.directives = [];
                                let t1 = true, s = false, a2 = f2;
                                for(; !e.Node.atDocumentBoundary(i, a2, e.Char.DIRECTIVES_END);)switch(a2 = I.startCommentOrEndBlankLine(i, a2), i[a2]){
                                    case `
`:
                                        if (t1) {
                                            let m = new r();
                                            a2 = m.parse({
                                                src: i
                                            }, a2), a2 < i.length && this.directives.push(m);
                                        } else a2 += 1, t1 = true;
                                        break;
                                    case "#":
                                        {
                                            let m = new h();
                                            a2 = m.parse({
                                                src: i
                                            }, a2), this.directives.push(m), t1 = false;
                                        }
                                        break;
                                    case "%":
                                        {
                                            let m = new E();
                                            a2 = m.parse({
                                                parent: this,
                                                src: i
                                            }, a2), this.directives.push(m), s = true, t1 = false;
                                        }
                                        break;
                                    default:
                                        return s ? this.error = new e.YAMLSemanticError(this, "Missing directives-end indicator line") : this.directives.length > 0 && (this.contents = this.directives, this.directives = []), a2;
                                }
                                return i[a2] ? (this.directivesEndMarker = new e.Range(a2, a2 + 3), a2 + 3) : (s ? this.error = new e.YAMLSemanticError(this, "Missing directives-end indicator line") : this.directives.length > 0 && (this.contents = this.directives, this.directives = []), a2);
                            }
                            parseContents(f2) {
                                let { parseNode: i, src: t1 } = this.context;
                                this.contents || (this.contents = []);
                                let s = f2;
                                for(; t1[s - 1] === "-";)s -= 1;
                                let a2 = e.Node.endOfWhiteSpace(t1, f2), m = s === f2;
                                for(this.valueRange = new e.Range(a2); !e.Node.atDocumentBoundary(t1, a2, e.Char.DOCUMENT_END);){
                                    switch(t1[a2]){
                                        case `
`:
                                            if (m) {
                                                let g = new r();
                                                a2 = g.parse({
                                                    src: t1
                                                }, a2), a2 < t1.length && this.contents.push(g);
                                            } else a2 += 1, m = true;
                                            s = a2;
                                            break;
                                        case "#":
                                            {
                                                let g = new h();
                                                a2 = g.parse({
                                                    src: t1
                                                }, a2), this.contents.push(g), m = false;
                                            }
                                            break;
                                        default:
                                            {
                                                let g = e.Node.endOfIndent(t1, a2), p = i({
                                                    atLineStart: m,
                                                    indent: -1,
                                                    inFlow: false,
                                                    inCollection: false,
                                                    lineStart: s,
                                                    parent: this
                                                }, g);
                                                if (!p) return this.valueRange.end = g;
                                                this.contents.push(p), a2 = p.range.end, m = false;
                                                let L = d(p);
                                                L && Array.prototype.push.apply(this.contents, L);
                                            }
                                    }
                                    a2 = I.startCommentOrEndBlankLine(t1, a2);
                                }
                                if (this.valueRange.end = a2, t1[a2] && (this.documentEndMarker = new e.Range(a2, a2 + 3), a2 += 3, t1[a2])) {
                                    if (a2 = e.Node.endOfWhiteSpace(t1, a2), t1[a2] === "#") {
                                        let g = new h();
                                        a2 = g.parse({
                                            src: t1
                                        }, a2), this.contents.push(g);
                                    }
                                    switch(t1[a2]){
                                        case `
`:
                                            a2 += 1;
                                            break;
                                        case void 0:
                                            break;
                                        default:
                                            this.error = new e.YAMLSyntaxError(this, "Document end marker line cannot have a non-comment suffix");
                                    }
                                }
                                return a2;
                            }
                            parse(f2, i) {
                                f2.root = this, this.context = f2;
                                let { src: t1 } = f2, s = t1.charCodeAt(i) === 65279 ? i + 1 : i;
                                return s = this.parseDirectives(s), s = this.parseContents(s), s;
                            }
                            setOrigRanges(f2, i) {
                                return i = super.setOrigRanges(f2, i), this.directives.forEach((t1)=>{
                                    i = t1.setOrigRanges(f2, i);
                                }), this.directivesEndMarker && (i = this.directivesEndMarker.setOrigRange(f2, i)), this.contents.forEach((t1)=>{
                                    i = t1.setOrigRanges(f2, i);
                                }), this.documentEndMarker && (i = this.documentEndMarker.setOrigRange(f2, i)), i;
                            }
                            toString() {
                                let { contents: f2, directives: i, value: t1 } = this;
                                if (t1 != null) return t1;
                                let s = i.join("");
                                return f2.length > 0 && ((i.length > 0 || f2[0].type === e.Type.COMMENT) && (s += `---
`), s += f2.join("")), s[s.length - 1] !== `
` && (s += `
`), s;
                            }
                            constructor(){
                                super(e.Type.DOCUMENT), this.directives = null, this.contents = null, this.directivesEndMarker = null, this.documentEndMarker = null;
                            }
                        }, S = class extends e.Node {
                            parse(f2, i) {
                                this.context = f2;
                                let { src: t1 } = f2, s = e.Node.endOfIdentifier(t1, i + 1);
                                return this.valueRange = new e.Range(i + 1, s), s = e.Node.endOfWhiteSpace(t1, s), s = this.parseComment(s), s;
                            }
                        }, M = {
                            CLIP: "CLIP",
                            KEEP: "KEEP",
                            STRIP: "STRIP"
                        }, T = class extends e.Node {
                            get includesTrailingLines() {
                                return this.chomping === M.KEEP;
                            }
                            get strValue() {
                                if (!this.valueRange || !this.context) return null;
                                let { start: f2, end: i } = this.valueRange, { indent: t1, src: s } = this.context;
                                if (this.valueRange.isEmpty()) return "";
                                let a2 = null, m = s[i - 1];
                                for(; m === `
` || m === "	" || m === " ";){
                                    if (i -= 1, i <= f2) {
                                        if (this.chomping === M.KEEP) break;
                                        return "";
                                    }
                                    m === `
` && (a2 = i), m = s[i - 1];
                                }
                                let g = i + 1;
                                a2 && (this.chomping === M.KEEP ? (g = a2, i = this.valueRange.end) : i = a2);
                                let u = t1 + this.blockIndent, p = this.type === e.Type.BLOCK_FOLDED, L = true, k = "", $ = "", K = false;
                                for(let V = f2; V < i; ++V){
                                    for(let ae = 0; ae < u && s[V] === " "; ++ae)V += 1;
                                    let z = s[V];
                                    if (z === `
`) $ === `
` ? k += `
` : $ = `
`;
                                    else {
                                        let ae = e.Node.endOfLine(s, V), ue = s.slice(V, ae);
                                        V = ae, p && (z === " " || z === "	") && V < g ? ($ === " " ? $ = `
` : !K && !L && $ === `
` && ($ = `

`), k += $ + ue, $ = ae < i && s[ae] || "", K = true) : (k += $ + ue, $ = p && V < g ? " " : `
`, K = false), L && ue !== "" && (L = false);
                                    }
                                }
                                return this.chomping === M.STRIP ? k : k + `
`;
                            }
                            parseBlockHeader(f2) {
                                let { src: i } = this.context, t1 = f2 + 1, s = "";
                                for(;;){
                                    let a2 = i[t1];
                                    switch(a2){
                                        case "-":
                                            this.chomping = M.STRIP;
                                            break;
                                        case "+":
                                            this.chomping = M.KEEP;
                                            break;
                                        case "0":
                                        case "1":
                                        case "2":
                                        case "3":
                                        case "4":
                                        case "5":
                                        case "6":
                                        case "7":
                                        case "8":
                                        case "9":
                                            s += a2;
                                            break;
                                        default:
                                            return this.blockIndent = Number(s) || null, this.header = new e.Range(f2, t1), t1;
                                    }
                                    t1 += 1;
                                }
                            }
                            parseBlockValue(f2) {
                                let { indent: i, src: t1 } = this.context, s = !!this.blockIndent, a2 = f2, m = f2, g = 1;
                                for(let u = t1[a2]; u === `
` && (a2 += 1, !e.Node.atDocumentBoundary(t1, a2)); u = t1[a2]){
                                    let p = e.Node.endOfBlockIndent(t1, i, a2);
                                    if (p === null) break;
                                    let L = t1[p], k = p - (a2 + i);
                                    if (this.blockIndent) {
                                        if (L && L !== `
` && k < this.blockIndent) {
                                            if (t1[p] === "#") break;
                                            if (!this.error) {
                                                let K = `Block scalars must not be less indented than their ${s ? "explicit indentation indicator" : "first line"}`;
                                                this.error = new e.YAMLSemanticError(this, K);
                                            }
                                        }
                                    } else if (t1[p] !== `
`) {
                                        if (k < g) {
                                            let $ = "Block scalars with more-indented leading empty lines must use an explicit indentation indicator";
                                            this.error = new e.YAMLSemanticError(this, $);
                                        }
                                        this.blockIndent = k;
                                    } else k > g && (g = k);
                                    t1[p] === `
` ? a2 = p : a2 = m = e.Node.endOfLine(t1, p);
                                }
                                return this.chomping !== M.KEEP && (a2 = t1[m] ? m + 1 : m), this.valueRange = new e.Range(f2 + 1, a2), a2;
                            }
                            parse(f2, i) {
                                this.context = f2;
                                let { src: t1 } = f2, s = this.parseBlockHeader(i);
                                return s = e.Node.endOfWhiteSpace(t1, s), s = this.parseComment(s), s = this.parseBlockValue(s), s;
                            }
                            setOrigRanges(f2, i) {
                                return i = super.setOrigRanges(f2, i), this.header ? this.header.setOrigRange(f2, i) : i;
                            }
                            constructor(f2, i){
                                super(f2, i), this.blockIndent = null, this.chomping = M.CLIP, this.header = null;
                            }
                        }, P = class extends e.Node {
                            prevNodeIsJsonLike() {
                                let f2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.items.length, i = this.items[f2 - 1];
                                return !!i && (i.jsonLike || i.type === e.Type.COMMENT && this.prevNodeIsJsonLike(f2 - 1));
                            }
                            parse(f2, i) {
                                this.context = f2;
                                let { parseNode: t1, src: s } = f2, { indent: a2, lineStart: m } = f2, g = s[i];
                                this.items = [
                                    {
                                        char: g,
                                        offset: i
                                    }
                                ];
                                let u = e.Node.endOfWhiteSpace(s, i + 1);
                                for(g = s[u]; g && g !== "]" && g !== "}";){
                                    switch(g){
                                        case `
`:
                                            {
                                                m = u + 1;
                                                let p = e.Node.endOfWhiteSpace(s, m);
                                                if (s[p] === `
`) {
                                                    let L = new r();
                                                    m = L.parse({
                                                        src: s
                                                    }, m), this.items.push(L);
                                                }
                                                if (u = e.Node.endOfIndent(s, m), u <= m + a2 && (g = s[u], u < m + a2 || g !== "]" && g !== "}")) {
                                                    let L = "Insufficient indentation in flow collection";
                                                    this.error = new e.YAMLSemanticError(this, L);
                                                }
                                            }
                                            break;
                                        case ",":
                                            this.items.push({
                                                char: g,
                                                offset: u
                                            }), u += 1;
                                            break;
                                        case "#":
                                            {
                                                let p = new h();
                                                u = p.parse({
                                                    src: s
                                                }, u), this.items.push(p);
                                            }
                                            break;
                                        case "?":
                                        case ":":
                                            {
                                                let p = s[u + 1];
                                                if (p === `
` || p === "	" || p === " " || p === "," || g === ":" && this.prevNodeIsJsonLike()) {
                                                    this.items.push({
                                                        char: g,
                                                        offset: u
                                                    }), u += 1;
                                                    break;
                                                }
                                            }
                                        default:
                                            {
                                                let p = t1({
                                                    atLineStart: false,
                                                    inCollection: false,
                                                    inFlow: true,
                                                    indent: -1,
                                                    lineStart: m,
                                                    parent: this
                                                }, u);
                                                if (!p) return this.valueRange = new e.Range(i, u), u;
                                                this.items.push(p), u = e.Node.normalizeOffset(s, p.range.end);
                                            }
                                    }
                                    u = e.Node.endOfWhiteSpace(s, u), g = s[u];
                                }
                                return this.valueRange = new e.Range(i, u + 1), g && (this.items.push({
                                    char: g,
                                    offset: u
                                }), u = e.Node.endOfWhiteSpace(s, u + 1), u = this.parseComment(u)), u;
                            }
                            setOrigRanges(f2, i) {
                                return i = super.setOrigRanges(f2, i), this.items.forEach((t1)=>{
                                    if (t1 instanceof e.Node) i = t1.setOrigRanges(f2, i);
                                    else if (f2.length === 0) t1.origOffset = t1.offset;
                                    else {
                                        let s = i;
                                        for(; s < f2.length && !(f2[s] > t1.offset);)++s;
                                        t1.origOffset = t1.offset + s, i = s;
                                    }
                                }), i;
                            }
                            toString() {
                                let { context: { src: f2 }, items: i, range: t1, value: s } = this;
                                if (s != null) return s;
                                let a2 = i.filter((u)=>u instanceof e.Node), m = "", g = t1.start;
                                return a2.forEach((u)=>{
                                    let p = f2.slice(g, u.range.start);
                                    g = u.range.end, m += p + String(u), m[m.length - 1] === `
` && f2[g - 1] !== `
` && f2[g] === `
` && (g += 1);
                                }), m += f2.slice(g, t1.end), e.Node.addStringTerminator(f2, t1.end, m);
                            }
                            constructor(f2, i){
                                super(f2, i), this.items = null;
                            }
                        }, C = class extends e.Node {
                            static endOfQuote(f2, i) {
                                let t1 = f2[i];
                                for(; t1 && t1 !== '"';)i += t1 === "\\" ? 2 : 1, t1 = f2[i];
                                return i + 1;
                            }
                            get strValue() {
                                if (!this.valueRange || !this.context) return null;
                                let f2 = [], { start: i, end: t1 } = this.valueRange, { indent: s, src: a2 } = this.context;
                                a2[t1 - 1] !== '"' && f2.push(new e.YAMLSyntaxError(this, 'Missing closing "quote'));
                                let m = "";
                                for(let g = i + 1; g < t1 - 1; ++g){
                                    let u = a2[g];
                                    if (u === `
`) {
                                        e.Node.atDocumentBoundary(a2, g + 1) && f2.push(new e.YAMLSemanticError(this, "Document boundary indicators are not allowed within string values"));
                                        let { fold: p, offset: L, error: k } = e.Node.foldNewline(a2, g, s);
                                        m += p, g = L, k && f2.push(new e.YAMLSemanticError(this, "Multi-line double-quoted string needs to be sufficiently indented"));
                                    } else if (u === "\\") switch(g += 1, a2[g]){
                                        case "0":
                                            m += "\0";
                                            break;
                                        case "a":
                                            m += "\x07";
                                            break;
                                        case "b":
                                            m += "\b";
                                            break;
                                        case "e":
                                            m += "\x1B";
                                            break;
                                        case "f":
                                            m += "\f";
                                            break;
                                        case "n":
                                            m += `
`;
                                            break;
                                        case "r":
                                            m += "\r";
                                            break;
                                        case "t":
                                            m += "	";
                                            break;
                                        case "v":
                                            m += "\v";
                                            break;
                                        case "N":
                                            m += "\x85";
                                            break;
                                        case "_":
                                            m += "\xA0";
                                            break;
                                        case "L":
                                            m += "\u2028";
                                            break;
                                        case "P":
                                            m += "\u2029";
                                            break;
                                        case " ":
                                            m += " ";
                                            break;
                                        case '"':
                                            m += '"';
                                            break;
                                        case "/":
                                            m += "/";
                                            break;
                                        case "\\":
                                            m += "\\";
                                            break;
                                        case "	":
                                            m += "	";
                                            break;
                                        case "x":
                                            m += this.parseCharCode(g + 1, 2, f2), g += 2;
                                            break;
                                        case "u":
                                            m += this.parseCharCode(g + 1, 4, f2), g += 4;
                                            break;
                                        case "U":
                                            m += this.parseCharCode(g + 1, 8, f2), g += 8;
                                            break;
                                        case `
`:
                                            for(; a2[g + 1] === " " || a2[g + 1] === "	";)g += 1;
                                            break;
                                        default:
                                            f2.push(new e.YAMLSyntaxError(this, `Invalid escape sequence ${a2.substr(g - 1, 2)}`)), m += "\\" + a2[g];
                                    }
                                    else if (u === " " || u === "	") {
                                        let p = g, L = a2[g + 1];
                                        for(; L === " " || L === "	";)g += 1, L = a2[g + 1];
                                        L !== `
` && (m += g > p ? a2.slice(p, g + 1) : u);
                                    } else m += u;
                                }
                                return f2.length > 0 ? {
                                    errors: f2,
                                    str: m
                                } : m;
                            }
                            parseCharCode(f2, i, t1) {
                                let { src: s } = this.context, a2 = s.substr(f2, i), g = a2.length === i && /^[0-9a-fA-F]+$/.test(a2) ? parseInt(a2, 16) : NaN;
                                return isNaN(g) ? (t1.push(new e.YAMLSyntaxError(this, `Invalid escape sequence ${s.substr(f2 - 2, i + 2)}`)), s.substr(f2 - 2, i + 2)) : String.fromCodePoint(g);
                            }
                            parse(f2, i) {
                                this.context = f2;
                                let { src: t1 } = f2, s = C.endOfQuote(t1, i + 1);
                                return this.valueRange = new e.Range(i, s), s = e.Node.endOfWhiteSpace(t1, s), s = this.parseComment(s), s;
                            }
                        }, q = class extends e.Node {
                            static endOfQuote(f2, i) {
                                let t1 = f2[i];
                                for(; t1;)if (t1 === "'") {
                                    if (f2[i + 1] !== "'") break;
                                    t1 = f2[i += 2];
                                } else t1 = f2[i += 1];
                                return i + 1;
                            }
                            get strValue() {
                                if (!this.valueRange || !this.context) return null;
                                let f2 = [], { start: i, end: t1 } = this.valueRange, { indent: s, src: a2 } = this.context;
                                a2[t1 - 1] !== "'" && f2.push(new e.YAMLSyntaxError(this, "Missing closing 'quote"));
                                let m = "";
                                for(let g = i + 1; g < t1 - 1; ++g){
                                    let u = a2[g];
                                    if (u === `
`) {
                                        e.Node.atDocumentBoundary(a2, g + 1) && f2.push(new e.YAMLSemanticError(this, "Document boundary indicators are not allowed within string values"));
                                        let { fold: p, offset: L, error: k } = e.Node.foldNewline(a2, g, s);
                                        m += p, g = L, k && f2.push(new e.YAMLSemanticError(this, "Multi-line single-quoted string needs to be sufficiently indented"));
                                    } else if (u === "'") m += u, g += 1, a2[g] !== "'" && f2.push(new e.YAMLSyntaxError(this, "Unescaped single quote? This should not happen."));
                                    else if (u === " " || u === "	") {
                                        let p = g, L = a2[g + 1];
                                        for(; L === " " || L === "	";)g += 1, L = a2[g + 1];
                                        L !== `
` && (m += g > p ? a2.slice(p, g + 1) : u);
                                    } else m += u;
                                }
                                return f2.length > 0 ? {
                                    errors: f2,
                                    str: m
                                } : m;
                            }
                            parse(f2, i) {
                                this.context = f2;
                                let { src: t1 } = f2, s = q.endOfQuote(t1, i + 1);
                                return this.valueRange = new e.Range(i, s), s = e.Node.endOfWhiteSpace(t1, s), s = this.parseComment(s), s;
                            }
                        };
                        function R(f2, i) {
                            switch(f2){
                                case e.Type.ALIAS:
                                    return new S(f2, i);
                                case e.Type.BLOCK_FOLDED:
                                case e.Type.BLOCK_LITERAL:
                                    return new T(f2, i);
                                case e.Type.FLOW_MAP:
                                case e.Type.FLOW_SEQ:
                                    return new P(f2, i);
                                case e.Type.MAP_KEY:
                                case e.Type.MAP_VALUE:
                                case e.Type.SEQ_ITEM:
                                    return new c(f2, i);
                                case e.Type.COMMENT:
                                case e.Type.PLAIN:
                                    return new e.PlainValue(f2, i);
                                case e.Type.QUOTE_DOUBLE:
                                    return new C(f2, i);
                                case e.Type.QUOTE_SINGLE:
                                    return new q(f2, i);
                                default:
                                    return null;
                            }
                        }
                        var B = class {
                            static parseType(f2, i, t1) {
                                switch(f2[i]){
                                    case "*":
                                        return e.Type.ALIAS;
                                    case ">":
                                        return e.Type.BLOCK_FOLDED;
                                    case "|":
                                        return e.Type.BLOCK_LITERAL;
                                    case "{":
                                        return e.Type.FLOW_MAP;
                                    case "[":
                                        return e.Type.FLOW_SEQ;
                                    case "?":
                                        return !t1 && e.Node.atBlank(f2, i + 1, true) ? e.Type.MAP_KEY : e.Type.PLAIN;
                                    case ":":
                                        return !t1 && e.Node.atBlank(f2, i + 1, true) ? e.Type.MAP_VALUE : e.Type.PLAIN;
                                    case "-":
                                        return !t1 && e.Node.atBlank(f2, i + 1, true) ? e.Type.SEQ_ITEM : e.Type.PLAIN;
                                    case '"':
                                        return e.Type.QUOTE_DOUBLE;
                                    case "'":
                                        return e.Type.QUOTE_SINGLE;
                                    default:
                                        return e.Type.PLAIN;
                                }
                            }
                            nodeStartsCollection(f2) {
                                let { inCollection: i, inFlow: t1, src: s } = this;
                                if (i || t1) return false;
                                if (f2 instanceof c) return true;
                                let a2 = f2.range.end;
                                return s[a2] === `
` || s[a2 - 1] === `
` ? false : (a2 = e.Node.endOfWhiteSpace(s, a2), s[a2] === ":");
                            }
                            parseProps(f2) {
                                let { inFlow: i, parent: t1, src: s } = this, a2 = [], m = false;
                                f2 = this.atLineStart ? e.Node.endOfIndent(s, f2) : e.Node.endOfWhiteSpace(s, f2);
                                let g = s[f2];
                                for(; g === e.Char.ANCHOR || g === e.Char.COMMENT || g === e.Char.TAG || g === `
`;){
                                    if (g === `
`) {
                                        let p = f2, L;
                                        do L = p + 1, p = e.Node.endOfIndent(s, L);
                                        while (s[p] === `
`)
                                        let k = p - (L + this.indent), $ = t1.type === e.Type.SEQ_ITEM && t1.context.atLineStart;
                                        if (s[p] !== "#" && !e.Node.nextNodeIsIndented(s[p], k, !$)) break;
                                        this.atLineStart = true, this.lineStart = L, m = false, f2 = p;
                                    } else if (g === e.Char.COMMENT) {
                                        let p = e.Node.endOfLine(s, f2 + 1);
                                        a2.push(new e.Range(f2, p)), f2 = p;
                                    } else {
                                        let p = e.Node.endOfIdentifier(s, f2 + 1);
                                        g === e.Char.TAG && s[p] === "," && /^[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+,\d\d\d\d(-\d\d){0,2}\/\S/.test(s.slice(f2 + 1, p + 13)) && (p = e.Node.endOfIdentifier(s, p + 5)), a2.push(new e.Range(f2, p)), m = true, f2 = e.Node.endOfWhiteSpace(s, p);
                                    }
                                    g = s[f2];
                                }
                                m && g === ":" && e.Node.atBlank(s, f2 + 1, true) && (f2 -= 1);
                                let u = B.parseType(s, f2, i);
                                return {
                                    props: a2,
                                    type: u,
                                    valueStart: f2
                                };
                            }
                            constructor(){
                                let f2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, { atLineStart: i, inCollection: t1, inFlow: s, indent: a2, lineStart: m, parent: g } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
                                e._defineProperty(this, "parseNode", (u, p)=>{
                                    if (e.Node.atDocumentBoundary(this.src, p)) return null;
                                    let L = new B(this, u), { props: k, type: $, valueStart: K } = L.parseProps(p), V = R($, k), z = V.parse(L, K);
                                    if (V.range = new e.Range(p, z), z <= p && (V.error = new Error("Node#parse consumed no characters"), V.error.parseEnd = z, V.error.source = V, V.range.end = p + 1), L.nodeStartsCollection(V)) {
                                        !V.error && !L.atLineStart && L.parent.type === e.Type.DOCUMENT && (V.error = new e.YAMLSyntaxError(V, "Block collection must not have preceding content here (e.g. directives-end indicator)"));
                                        let ae = new y(V);
                                        return z = ae.parse(new B(L), z), ae.range = new e.Range(p, z), ae;
                                    }
                                    return V;
                                }), this.atLineStart = i != null ? i : f2.atLineStart || false, this.inCollection = t1 != null ? t1 : f2.inCollection || false, this.inFlow = s != null ? s : f2.inFlow || false, this.indent = a2 != null ? a2 : f2.indent, this.lineStart = m != null ? m : f2.lineStart, this.parent = g != null ? g : f2.parent || {}, this.root = f2.root, this.src = f2.src;
                            }
                        };
                        function U(f2) {
                            let i = [];
                            f2.indexOf("\r") !== -1 && (f2 = f2.replace(/\r\n?/g, (a2, m)=>(a2.length > 1 && i.push(m), `
`)));
                            let t1 = [], s = 0;
                            do {
                                let a2 = new I(), m = new B({
                                    src: f2
                                });
                                s = a2.parse(m, s), t1.push(a2);
                            }while (s < f2.length)
                            return t1.setOrigRanges = ()=>{
                                if (i.length === 0) return false;
                                for(let m = 1; m < i.length; ++m)i[m] -= m;
                                let a2 = 0;
                                for(let m = 0; m < t1.length; ++m)a2 = t1[m].setOrigRanges(i, a2);
                                return i.splice(0, i.length), true;
                            }, t1.toString = ()=>t1.join(`...
`), t1;
                        }
                        n.parse = U;
                    }
                }), ke = D({
                    "node_modules/yaml/dist/resolveSeq-d03cb037.js" (n) {
                        "use strict";
                        Y();
                        var e = Me();
                        function r(o, l, _2) {
                            return _2 ? `#${_2.replace(/[\s\S]^/gm, `$&${l}#`)}
${l}${o}` : o;
                        }
                        function c(o, l, _2) {
                            return _2 ? _2.indexOf(`
`) === -1 ? `${o} #${_2}` : `${o}
` + _2.replace(/^/gm, `${l || ""}#`) : o;
                        }
                        var h = class {
                        };
                        function d(o, l, _2) {
                            if (Array.isArray(o)) return o.map((v, b)=>d(v, String(b), _2));
                            if (o && typeof o.toJSON == "function") {
                                let v = _2 && _2.anchors && _2.anchors.get(o);
                                v && (_2.onCreate = (w)=>{
                                    v.res = w, delete _2.onCreate;
                                });
                                let b = o.toJSON(l, _2);
                                return v && _2.onCreate && _2.onCreate(b), b;
                            }
                            return (!_2 || !_2.keep) && typeof o == "bigint" ? Number(o) : o;
                        }
                        var y = class extends h {
                            toJSON(o, l) {
                                return l && l.keep ? this.value : d(this.value, o, l);
                            }
                            toString() {
                                return String(this.value);
                            }
                            constructor(o){
                                super(), this.value = o;
                            }
                        };
                        function E(o, l, _2) {
                            let v = _2;
                            for(let b = l.length - 1; b >= 0; --b){
                                let w = l[b];
                                if (Number.isInteger(w) && w >= 0) {
                                    let A2 = [];
                                    A2[w] = v, v = A2;
                                } else {
                                    let A2 = {};
                                    Object.defineProperty(A2, w, {
                                        value: v,
                                        writable: true,
                                        enumerable: true,
                                        configurable: true
                                    }), v = A2;
                                }
                            }
                            return o.createNode(v, false);
                        }
                        var I = (o)=>o == null || typeof o == "object" && o[Symbol.iterator]().next().done, S = class extends h {
                            addIn(o, l) {
                                if (I(o)) this.add(l);
                                else {
                                    let [_2, ...v] = o, b = this.get(_2, true);
                                    if (b instanceof S) b.addIn(v, l);
                                    else if (b === void 0 && this.schema) this.set(_2, E(this.schema, v, l));
                                    else throw new Error(`Expected YAML collection at ${_2}. Remaining path: ${v}`);
                                }
                            }
                            deleteIn(o) {
                                let [l, ..._2] = o;
                                if (_2.length === 0) return this.delete(l);
                                let v = this.get(l, true);
                                if (v instanceof S) return v.deleteIn(_2);
                                throw new Error(`Expected YAML collection at ${l}. Remaining path: ${_2}`);
                            }
                            getIn(o, l) {
                                let [_2, ...v] = o, b = this.get(_2, true);
                                return v.length === 0 ? !l && b instanceof y ? b.value : b : b instanceof S ? b.getIn(v, l) : void 0;
                            }
                            hasAllNullValues() {
                                return this.items.every((o)=>{
                                    if (!o || o.type !== "PAIR") return false;
                                    let l = o.value;
                                    return l == null || l instanceof y && l.value == null && !l.commentBefore && !l.comment && !l.tag;
                                });
                            }
                            hasIn(o) {
                                let [l, ..._2] = o;
                                if (_2.length === 0) return this.has(l);
                                let v = this.get(l, true);
                                return v instanceof S ? v.hasIn(_2) : false;
                            }
                            setIn(o, l) {
                                let [_2, ...v] = o;
                                if (v.length === 0) this.set(_2, l);
                                else {
                                    let b = this.get(_2, true);
                                    if (b instanceof S) b.setIn(v, l);
                                    else if (b === void 0 && this.schema) this.set(_2, E(this.schema, v, l));
                                    else throw new Error(`Expected YAML collection at ${_2}. Remaining path: ${v}`);
                                }
                            }
                            toJSON() {
                                return null;
                            }
                            toString(o, l, _2, v) {
                                let { blockItem: b, flowChars: w, isMap: A2, itemIndent: N } = l, { indent: j, indentStep: F, stringify: Q } = o, H = this.type === e.Type.FLOW_MAP || this.type === e.Type.FLOW_SEQ || o.inFlow;
                                H && (N += F);
                                let oe = A2 && this.hasAllNullValues();
                                o = Object.assign({}, o, {
                                    allNullValues: oe,
                                    indent: N,
                                    inFlow: H,
                                    type: null
                                });
                                let le = false, Z = false, ee = this.items.reduce((de, ne, he)=>{
                                    let ce;
                                    ne && (!le && ne.spaceBefore && de.push({
                                        type: "comment",
                                        str: ""
                                    }), ne.commentBefore && ne.commentBefore.match(/^.*$/gm).forEach((Ie)=>{
                                        de.push({
                                            type: "comment",
                                            str: `#${Ie}`
                                        });
                                    }), ne.comment && (ce = ne.comment), H && (!le && ne.spaceBefore || ne.commentBefore || ne.comment || ne.key && (ne.key.commentBefore || ne.key.comment) || ne.value && (ne.value.commentBefore || ne.value.comment)) && (Z = true)), le = false;
                                    let fe = Q(ne, o, ()=>ce = null, ()=>le = true);
                                    return H && !Z && fe.includes(`
`) && (Z = true), H && he < this.items.length - 1 && (fe += ","), fe = c(fe, N, ce), le && (ce || H) && (le = false), de.push({
                                        type: "item",
                                        str: fe
                                    }), de;
                                }, []), X;
                                if (ee.length === 0) X = w.start + w.end;
                                else if (H) {
                                    let { start: de, end: ne } = w, he = ee.map((ce)=>ce.str);
                                    if (Z || he.reduce((ce, fe)=>ce + fe.length + 2, 2) > S.maxFlowStringSingleLineLength) {
                                        X = de;
                                        for (let ce of he)X += ce ? `
${F}${j}${ce}` : `
`;
                                        X += `
${j}${ne}`;
                                    } else X = `${de} ${he.join(" ")} ${ne}`;
                                } else {
                                    let de = ee.map(b);
                                    X = de.shift();
                                    for (let ne of de)X += ne ? `
${j}${ne}` : `
`;
                                }
                                return this.comment ? (X += `
` + this.comment.replace(/^/gm, `${j}#`), _2 && _2()) : le && v && v(), X;
                            }
                            constructor(o){
                                super(), e._defineProperty(this, "items", []), this.schema = o;
                            }
                        };
                        e._defineProperty(S, "maxFlowStringSingleLineLength", 60);
                        function M(o) {
                            let l = o instanceof y ? o.value : o;
                            return l && typeof l == "string" && (l = Number(l)), Number.isInteger(l) && l >= 0 ? l : null;
                        }
                        var T = class extends S {
                            add(o) {
                                this.items.push(o);
                            }
                            delete(o) {
                                let l = M(o);
                                return typeof l != "number" ? false : this.items.splice(l, 1).length > 0;
                            }
                            get(o, l) {
                                let _2 = M(o);
                                if (typeof _2 != "number") return;
                                let v = this.items[_2];
                                return !l && v instanceof y ? v.value : v;
                            }
                            has(o) {
                                let l = M(o);
                                return typeof l == "number" && l < this.items.length;
                            }
                            set(o, l) {
                                let _2 = M(o);
                                if (typeof _2 != "number") throw new Error(`Expected a valid index, not ${o}.`);
                                this.items[_2] = l;
                            }
                            toJSON(o, l) {
                                let _2 = [];
                                l && l.onCreate && l.onCreate(_2);
                                let v = 0;
                                for (let b of this.items)_2.push(d(b, String(v++), l));
                                return _2;
                            }
                            toString(o, l, _2) {
                                return o ? super.toString(o, {
                                    blockItem: (v)=>v.type === "comment" ? v.str : `- ${v.str}`,
                                    flowChars: {
                                        start: "[",
                                        end: "]"
                                    },
                                    isMap: false,
                                    itemIndent: (o.indent || "") + "  "
                                }, l, _2) : JSON.stringify(this);
                            }
                        }, P = (o, l, _2)=>l === null ? "" : typeof l != "object" ? String(l) : o instanceof h && _2 && _2.doc ? o.toString({
                                anchors: /* @__PURE__ */ Object.create(null),
                                doc: _2.doc,
                                indent: "",
                                indentStep: _2.indentStep,
                                inFlow: true,
                                inStringifyKey: true,
                                stringify: _2.stringify
                            }) : JSON.stringify(l), C = class extends h {
                            get commentBefore() {
                                return this.key instanceof h ? this.key.commentBefore : void 0;
                            }
                            set commentBefore(o) {
                                if (this.key == null && (this.key = new y(null)), this.key instanceof h) this.key.commentBefore = o;
                                else {
                                    let l = "Pair.commentBefore is an alias for Pair.key.commentBefore. To set it, the key must be a Node.";
                                    throw new Error(l);
                                }
                            }
                            addToJSMap(o, l) {
                                let _2 = d(this.key, "", o);
                                if (l instanceof Map) {
                                    let v = d(this.value, _2, o);
                                    l.set(_2, v);
                                } else if (l instanceof Set) l.add(_2);
                                else {
                                    let v = P(this.key, _2, o), b = d(this.value, v, o);
                                    v in l ? Object.defineProperty(l, v, {
                                        value: b,
                                        writable: true,
                                        enumerable: true,
                                        configurable: true
                                    }) : l[v] = b;
                                }
                                return l;
                            }
                            toJSON(o, l) {
                                let _2 = l && l.mapAsMap ? /* @__PURE__ */ new Map() : {};
                                return this.addToJSMap(l, _2);
                            }
                            toString(o, l, _2) {
                                if (!o || !o.doc) return JSON.stringify(this);
                                let { indent: v, indentSeq: b, simpleKeys: w } = o.doc.options, { key: A2, value: N } = this, j = A2 instanceof h && A2.comment;
                                if (w) {
                                    if (j) throw new Error("With simple keys, key nodes cannot have comments");
                                    if (A2 instanceof S) {
                                        let ce = "With simple keys, collection cannot be used as a key value";
                                        throw new Error(ce);
                                    }
                                }
                                let F = !w && (!A2 || j || (A2 instanceof h ? A2 instanceof S || A2.type === e.Type.BLOCK_FOLDED || A2.type === e.Type.BLOCK_LITERAL : typeof A2 == "object")), { doc: Q, indent: H, indentStep: oe, stringify: le } = o;
                                o = Object.assign({}, o, {
                                    implicitKey: !F,
                                    indent: H + oe
                                });
                                let Z = false, ee = le(A2, o, ()=>j = null, ()=>Z = true);
                                if (ee = c(ee, o.indent, j), !F && ee.length > 1024) {
                                    if (w) throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
                                    F = true;
                                }
                                if (o.allNullValues && !w) return this.comment ? (ee = c(ee, o.indent, this.comment), l && l()) : Z && !j && _2 && _2(), o.inFlow && !F ? ee : `? ${ee}`;
                                ee = F ? `? ${ee}
${H}:` : `${ee}:`, this.comment && (ee = c(ee, o.indent, this.comment), l && l());
                                let X = "", de = null;
                                if (N instanceof h) {
                                    if (N.spaceBefore && (X = `
`), N.commentBefore) {
                                        let ce = N.commentBefore.replace(/^/gm, `${o.indent}#`);
                                        X += `
${ce}`;
                                    }
                                    de = N.comment;
                                } else N && typeof N == "object" && (N = Q.schema.createNode(N, true));
                                o.implicitKey = false, !F && !this.comment && N instanceof y && (o.indentAtStart = ee.length + 1), Z = false, !b && v >= 2 && !o.inFlow && !F && N instanceof T && N.type !== e.Type.FLOW_SEQ && !N.tag && !Q.anchors.getName(N) && (o.indent = o.indent.substr(2));
                                let ne = le(N, o, ()=>de = null, ()=>Z = true), he = " ";
                                return X || this.comment ? he = `${X}
${o.indent}` : !F && N instanceof S ? (!(ne[0] === "[" || ne[0] === "{") || ne.includes(`
`)) && (he = `
${o.indent}`) : ne[0] === `
` && (he = ""), Z && !de && _2 && _2(), c(ee + he + ne, o.indent, de);
                            }
                            constructor(o){
                                let l = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
                                super(), this.key = o, this.value = l, this.type = C.Type.PAIR;
                            }
                        };
                        e._defineProperty(C, "Type", {
                            PAIR: "PAIR",
                            MERGE_PAIR: "MERGE_PAIR"
                        });
                        var q = (o, l)=>{
                            if (o instanceof R) {
                                let _2 = l.get(o.source);
                                return _2.count * _2.aliasCount;
                            } else if (o instanceof S) {
                                let _2 = 0;
                                for (let v of o.items){
                                    let b = q(v, l);
                                    b > _2 && (_2 = b);
                                }
                                return _2;
                            } else if (o instanceof C) {
                                let _2 = q(o.key, l), v = q(o.value, l);
                                return Math.max(_2, v);
                            }
                            return 1;
                        }, R = class extends h {
                            static stringify(o, l) {
                                let { range: _2, source: v } = o, { anchors: b, doc: w, implicitKey: A2, inStringifyKey: N } = l, j = Object.keys(b).find((Q)=>b[Q] === v);
                                if (!j && N && (j = w.anchors.getName(v) || w.anchors.newName()), j) return `*${j}${A2 ? " " : ""}`;
                                let F = w.anchors.getName(v) ? "Alias node must be after source node" : "Source node not found for alias node";
                                throw new Error(`${F} [${_2}]`);
                            }
                            set tag(o) {
                                throw new Error("Alias nodes cannot have tags");
                            }
                            toJSON(o, l) {
                                if (!l) return d(this.source, o, l);
                                let { anchors: _2, maxAliasCount: v } = l, b = _2.get(this.source);
                                if (!b || b.res === void 0) {
                                    let w = "This should not happen: Alias anchor was not resolved?";
                                    throw this.cstNode ? new e.YAMLReferenceError(this.cstNode, w) : new ReferenceError(w);
                                }
                                if (v >= 0 && (b.count += 1, b.aliasCount === 0 && (b.aliasCount = q(this.source, _2)), b.count * b.aliasCount > v)) {
                                    let w = "Excessive alias count indicates a resource exhaustion attack";
                                    throw this.cstNode ? new e.YAMLReferenceError(this.cstNode, w) : new ReferenceError(w);
                                }
                                return b.res;
                            }
                            toString(o) {
                                return R.stringify(this, o);
                            }
                            constructor(o){
                                super(), this.source = o, this.type = e.Type.ALIAS;
                            }
                        };
                        e._defineProperty(R, "default", true);
                        function B(o, l) {
                            let _2 = l instanceof y ? l.value : l;
                            for (let v of o)if (v instanceof C && (v.key === l || v.key === _2 || v.key && v.key.value === _2)) return v;
                        }
                        var U = class extends S {
                            add(o, l) {
                                o ? o instanceof C || (o = new C(o.key || o, o.value)) : o = new C(o);
                                let _2 = B(this.items, o.key), v = this.schema && this.schema.sortMapEntries;
                                if (_2) if (l) _2.value = o.value;
                                else throw new Error(`Key ${o.key} already set`);
                                else if (v) {
                                    let b = this.items.findIndex((w)=>v(o, w) < 0);
                                    b === -1 ? this.items.push(o) : this.items.splice(b, 0, o);
                                } else this.items.push(o);
                            }
                            delete(o) {
                                let l = B(this.items, o);
                                return l ? this.items.splice(this.items.indexOf(l), 1).length > 0 : false;
                            }
                            get(o, l) {
                                let _2 = B(this.items, o), v = _2 && _2.value;
                                return !l && v instanceof y ? v.value : v;
                            }
                            has(o) {
                                return !!B(this.items, o);
                            }
                            set(o, l) {
                                this.add(new C(o, l), true);
                            }
                            toJSON(o, l, _2) {
                                let v = _2 ? new _2() : l && l.mapAsMap ? /* @__PURE__ */ new Map() : {};
                                l && l.onCreate && l.onCreate(v);
                                for (let b of this.items)b.addToJSMap(l, v);
                                return v;
                            }
                            toString(o, l, _2) {
                                if (!o) return JSON.stringify(this);
                                for (let v of this.items)if (!(v instanceof C)) throw new Error(`Map items must all be pairs; found ${JSON.stringify(v)} instead`);
                                return super.toString(o, {
                                    blockItem: (v)=>v.str,
                                    flowChars: {
                                        start: "{",
                                        end: "}"
                                    },
                                    isMap: true,
                                    itemIndent: o.indent || ""
                                }, l, _2);
                            }
                        }, f2 = "<<", i = class extends C {
                            addToJSMap(o, l) {
                                for (let { source: _2 } of this.value.items){
                                    if (!(_2 instanceof U)) throw new Error("Merge sources must be maps");
                                    let v = _2.toJSON(null, o, Map);
                                    for (let [b, w] of v)l instanceof Map ? l.has(b) || l.set(b, w) : l instanceof Set ? l.add(b) : Object.prototype.hasOwnProperty.call(l, b) || Object.defineProperty(l, b, {
                                        value: w,
                                        writable: true,
                                        enumerable: true,
                                        configurable: true
                                    });
                                }
                                return l;
                            }
                            toString(o, l) {
                                let _2 = this.value;
                                if (_2.items.length > 1) return super.toString(o, l);
                                this.value = _2.items[0];
                                let v = super.toString(o, l);
                                return this.value = _2, v;
                            }
                            constructor(o){
                                if (o instanceof C) {
                                    let l = o.value;
                                    l instanceof T || (l = new T(), l.items.push(o.value), l.range = o.value.range), super(o.key, l), this.range = o.range;
                                } else super(new y(f2), new T());
                                this.type = C.Type.MERGE_PAIR;
                            }
                        }, t1 = {
                            defaultType: e.Type.BLOCK_LITERAL,
                            lineWidth: 76
                        }, s = {
                            trueStr: "true",
                            falseStr: "false"
                        }, a2 = {
                            asBigInt: false
                        }, m = {
                            nullStr: "null"
                        }, g = {
                            defaultType: e.Type.PLAIN,
                            doubleQuoted: {
                                jsonEncoding: false,
                                minMultiLineLength: 40
                            },
                            fold: {
                                lineWidth: 80,
                                minContentWidth: 20
                            }
                        };
                        function u(o, l, _2) {
                            for (let { format: v, test: b, resolve: w } of l)if (b) {
                                let A2 = o.match(b);
                                if (A2) {
                                    let N = w.apply(null, A2);
                                    return N instanceof y || (N = new y(N)), v && (N.format = v), N;
                                }
                            }
                            return _2 && (o = _2(o)), new y(o);
                        }
                        var p = "flow", L = "block", k = "quoted", $ = (o, l)=>{
                            let _2 = o[l + 1];
                            for(; _2 === " " || _2 === "	";){
                                do _2 = o[l += 1];
                                while (_2 && _2 !== `
`)
                                _2 = o[l + 1];
                            }
                            return l;
                        };
                        function K(o, l, _2, v) {
                            let { indentAtStart: b, lineWidth: w = 80, minContentWidth: A2 = 20, onFold: N, onOverflow: j } = v;
                            if (!w || w < 0) return o;
                            let F = Math.max(1 + A2, 1 + w - l.length);
                            if (o.length <= F) return o;
                            let Q = [], H = {}, oe = w - l.length;
                            typeof b == "number" && (b > w - Math.max(2, A2) ? Q.push(0) : oe = w - b);
                            let le, Z, ee = false, X = -1, de = -1, ne = -1;
                            _2 === L && (X = $(o, X), X !== -1 && (oe = X + F));
                            for(let ce; ce = o[X += 1];){
                                if (_2 === k && ce === "\\") {
                                    switch(de = X, o[X + 1]){
                                        case "x":
                                            X += 3;
                                            break;
                                        case "u":
                                            X += 5;
                                            break;
                                        case "U":
                                            X += 9;
                                            break;
                                        default:
                                            X += 1;
                                    }
                                    ne = X;
                                }
                                if (ce === `
`) _2 === L && (X = $(o, X)), oe = X + F, le = void 0;
                                else {
                                    if (ce === " " && Z && Z !== " " && Z !== `
` && Z !== "	") {
                                        let fe = o[X + 1];
                                        fe && fe !== " " && fe !== `
` && fe !== "	" && (le = X);
                                    }
                                    if (X >= oe) if (le) Q.push(le), oe = le + F, le = void 0;
                                    else if (_2 === k) {
                                        for(; Z === " " || Z === "	";)Z = ce, ce = o[X += 1], ee = true;
                                        let fe = X > ne + 1 ? X - 2 : de - 1;
                                        if (H[fe]) return o;
                                        Q.push(fe), H[fe] = true, oe = fe + F, le = void 0;
                                    } else ee = true;
                                }
                                Z = ce;
                            }
                            if (ee && j && j(), Q.length === 0) return o;
                            N && N();
                            let he = o.slice(0, Q[0]);
                            for(let ce = 0; ce < Q.length; ++ce){
                                let fe = Q[ce], Ie = Q[ce + 1] || o.length;
                                fe === 0 ? he = `
${l}${o.slice(0, Ie)}` : (_2 === k && H[fe] && (he += `${o[fe]}\\`), he += `
${l}${o.slice(fe + 1, Ie)}`);
                            }
                            return he;
                        }
                        var V = (o)=>{
                            let { indentAtStart: l } = o;
                            return l ? Object.assign({
                                indentAtStart: l
                            }, g.fold) : g.fold;
                        }, z = (o)=>/^(%|---|\.\.\.)/m.test(o);
                        function ae(o, l, _2) {
                            if (!l || l < 0) return false;
                            let v = l - _2, b = o.length;
                            if (b <= v) return false;
                            for(let w = 0, A2 = 0; w < b; ++w)if (o[w] === `
`) {
                                if (w - A2 > v) return true;
                                if (A2 = w + 1, b - A2 <= v) return false;
                            }
                            return true;
                        }
                        function ue(o, l) {
                            let { implicitKey: _2 } = l, { jsonEncoding: v, minMultiLineLength: b } = g.doubleQuoted, w = JSON.stringify(o);
                            if (v) return w;
                            let A2 = l.indent || (z(o) ? "  " : ""), N = "", j = 0;
                            for(let F = 0, Q = w[F]; Q; Q = w[++F])if (Q === " " && w[F + 1] === "\\" && w[F + 2] === "n" && (N += w.slice(j, F) + "\\ ", F += 1, j = F, Q = "\\"), Q === "\\") switch(w[F + 1]){
                                case "u":
                                    {
                                        N += w.slice(j, F);
                                        let H = w.substr(F + 2, 4);
                                        switch(H){
                                            case "0000":
                                                N += "\\0";
                                                break;
                                            case "0007":
                                                N += "\\a";
                                                break;
                                            case "000b":
                                                N += "\\v";
                                                break;
                                            case "001b":
                                                N += "\\e";
                                                break;
                                            case "0085":
                                                N += "\\N";
                                                break;
                                            case "00a0":
                                                N += "\\_";
                                                break;
                                            case "2028":
                                                N += "\\L";
                                                break;
                                            case "2029":
                                                N += "\\P";
                                                break;
                                            default:
                                                H.substr(0, 2) === "00" ? N += "\\x" + H.substr(2) : N += w.substr(F, 6);
                                        }
                                        F += 5, j = F + 1;
                                    }
                                    break;
                                case "n":
                                    if (_2 || w[F + 2] === '"' || w.length < b) F += 1;
                                    else {
                                        for(N += w.slice(j, F) + `

`; w[F + 2] === "\\" && w[F + 3] === "n" && w[F + 4] !== '"';)N += `
`, F += 2;
                                        N += A2, w[F + 2] === " " && (N += "\\"), F += 1, j = F + 1;
                                    }
                                    break;
                                default:
                                    F += 1;
                            }
                            return N = j ? N + w.slice(j) : w, _2 ? N : K(N, A2, k, V(l));
                        }
                        function pe(o, l) {
                            if (l.implicitKey) {
                                if (/\n/.test(o)) return ue(o, l);
                            } else if (/[ \t]\n|\n[ \t]/.test(o)) return ue(o, l);
                            let _2 = l.indent || (z(o) ? "  " : ""), v = "'" + o.replace(/'/g, "''").replace(/\n+/g, `$&
${_2}`) + "'";
                            return l.implicitKey ? v : K(v, _2, p, V(l));
                        }
                        function ge(o, l, _2, v) {
                            let { comment: b, type: w, value: A2 } = o;
                            if (/\n[\t ]+$/.test(A2) || /^\s*$/.test(A2)) return ue(A2, l);
                            let N = l.indent || (l.forceBlockIndent || z(A2) ? "  " : ""), j = N ? "2" : "1", F = w === e.Type.BLOCK_FOLDED ? false : w === e.Type.BLOCK_LITERAL ? true : !ae(A2, g.fold.lineWidth, N.length), Q = F ? "|" : ">";
                            if (!A2) return Q + `
`;
                            let H = "", oe = "";
                            if (A2 = A2.replace(/[\n\t ]*$/, (Z)=>{
                                let ee = Z.indexOf(`
`);
                                return ee === -1 ? Q += "-" : (A2 === Z || ee !== Z.length - 1) && (Q += "+", v && v()), oe = Z.replace(/\n$/, ""), "";
                            }).replace(/^[\n ]*/, (Z)=>{
                                Z.indexOf(" ") !== -1 && (Q += j);
                                let ee = Z.match(/ +$/);
                                return ee ? (H = Z.slice(0, -ee[0].length), ee[0]) : (H = Z, "");
                            }), oe && (oe = oe.replace(/\n+(?!\n|$)/g, `$&${N}`)), H && (H = H.replace(/\n+/g, `$&${N}`)), b && (Q += " #" + b.replace(/ ?[\r\n]+/g, " "), _2 && _2()), !A2) return `${Q}${j}
${N}${oe}`;
                            if (F) return A2 = A2.replace(/\n+/g, `$&${N}`), `${Q}
${N}${H}${A2}${oe}`;
                            A2 = A2.replace(/\n+/g, `
$&`).replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${N}`);
                            let le = K(`${H}${A2}${oe}`, N, L, g.fold);
                            return `${Q}
${N}${le}`;
                        }
                        function O(o, l, _2, v) {
                            let { comment: b, type: w, value: A2 } = o, { actualString: N, implicitKey: j, indent: F, inFlow: Q } = l;
                            if (j && /[\n[\]{},]/.test(A2) || Q && /[[\]{},]/.test(A2)) return ue(A2, l);
                            if (!A2 || /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(A2)) return j || Q || A2.indexOf(`
`) === -1 ? A2.indexOf('"') !== -1 && A2.indexOf("'") === -1 ? pe(A2, l) : ue(A2, l) : ge(o, l, _2, v);
                            if (!j && !Q && w !== e.Type.PLAIN && A2.indexOf(`
`) !== -1) return ge(o, l, _2, v);
                            if (F === "" && z(A2)) return l.forceBlockIndent = true, ge(o, l, _2, v);
                            let H = A2.replace(/\n+/g, `$&
${F}`);
                            if (N) {
                                let { tags: le } = l.doc.schema;
                                if (typeof u(H, le, le.scalarFallback).value != "string") return ue(A2, l);
                            }
                            let oe = j ? H : K(H, F, p, V(l));
                            return b && !Q && (oe.indexOf(`
`) !== -1 || b.indexOf(`
`) !== -1) ? (_2 && _2(), r(oe, F, b)) : oe;
                        }
                        function W(o, l, _2, v) {
                            let { defaultType: b } = g, { implicitKey: w, inFlow: A2 } = l, { type: N, value: j } = o;
                            typeof j != "string" && (j = String(j), o = Object.assign({}, o, {
                                value: j
                            }));
                            let F = (H)=>{
                                switch(H){
                                    case e.Type.BLOCK_FOLDED:
                                    case e.Type.BLOCK_LITERAL:
                                        return ge(o, l, _2, v);
                                    case e.Type.QUOTE_DOUBLE:
                                        return ue(j, l);
                                    case e.Type.QUOTE_SINGLE:
                                        return pe(j, l);
                                    case e.Type.PLAIN:
                                        return O(o, l, _2, v);
                                    default:
                                        return null;
                                }
                            };
                            (N !== e.Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(j) || (w || A2) && (N === e.Type.BLOCK_FOLDED || N === e.Type.BLOCK_LITERAL)) && (N = e.Type.QUOTE_DOUBLE);
                            let Q = F(N);
                            if (Q === null && (Q = F(b), Q === null)) throw new Error(`Unsupported default string type ${b}`);
                            return Q;
                        }
                        function J(o) {
                            let { format: l, minFractionDigits: _2, tag: v, value: b } = o;
                            if (typeof b == "bigint") return String(b);
                            if (!isFinite(b)) return isNaN(b) ? ".nan" : b < 0 ? "-.inf" : ".inf";
                            let w = JSON.stringify(b);
                            if (!l && _2 && (!v || v === "tag:yaml.org,2002:float") && /^\d/.test(w)) {
                                let A2 = w.indexOf(".");
                                A2 < 0 && (A2 = w.length, w += ".");
                                let N = _2 - (w.length - A2 - 1);
                                for(; N-- > 0;)w += "0";
                            }
                            return w;
                        }
                        function x(o, l) {
                            let _2, v;
                            switch(l.type){
                                case e.Type.FLOW_MAP:
                                    _2 = "}", v = "flow map";
                                    break;
                                case e.Type.FLOW_SEQ:
                                    _2 = "]", v = "flow sequence";
                                    break;
                                default:
                                    o.push(new e.YAMLSemanticError(l, "Not a flow collection!?"));
                                    return;
                            }
                            let b;
                            for(let w = l.items.length - 1; w >= 0; --w){
                                let A2 = l.items[w];
                                if (!A2 || A2.type !== e.Type.COMMENT) {
                                    b = A2;
                                    break;
                                }
                            }
                            if (b && b.char !== _2) {
                                let w = `Expected ${v} to end with ${_2}`, A2;
                                typeof b.offset == "number" ? (A2 = new e.YAMLSemanticError(l, w), A2.offset = b.offset + 1) : (A2 = new e.YAMLSemanticError(b, w), b.range && b.range.end && (A2.offset = b.range.end - b.range.start)), o.push(A2);
                            }
                        }
                        function G(o, l) {
                            let _2 = l.context.src[l.range.start - 1];
                            if (_2 !== `
` && _2 !== "	" && _2 !== " ") {
                                let v = "Comments must be separated from other tokens by white space characters";
                                o.push(new e.YAMLSemanticError(l, v));
                            }
                        }
                        function re(o, l) {
                            let _2 = String(l), v = _2.substr(0, 8) + "..." + _2.substr(-8);
                            return new e.YAMLSemanticError(o, `The "${v}" key is too long`);
                        }
                        function _e(o, l) {
                            for (let { afterKey: _2, before: v, comment: b } of l){
                                let w = o.items[v];
                                w ? (_2 && w.value && (w = w.value), b === void 0 ? (_2 || !w.commentBefore) && (w.spaceBefore = true) : w.commentBefore ? w.commentBefore += `
` + b : w.commentBefore = b) : b !== void 0 && (o.comment ? o.comment += `
` + b : o.comment = b);
                            }
                        }
                        function ye(o, l) {
                            let _2 = l.strValue;
                            return _2 ? typeof _2 == "string" ? _2 : (_2.errors.forEach((v)=>{
                                v.source || (v.source = l), o.errors.push(v);
                            }), _2.str) : "";
                        }
                        function be(o, l) {
                            let { handle: _2, suffix: v } = l.tag, b = o.tagPrefixes.find((w)=>w.handle === _2);
                            if (!b) {
                                let w = o.getDefaults().tagPrefixes;
                                if (w && (b = w.find((A2)=>A2.handle === _2)), !b) throw new e.YAMLSemanticError(l, `The ${_2} tag handle is non-default and was not declared.`);
                            }
                            if (!v) throw new e.YAMLSemanticError(l, `The ${_2} tag has no suffix.`);
                            if (_2 === "!" && (o.version || o.options.version) === "1.0") {
                                if (v[0] === "^") return o.warnings.push(new e.YAMLWarning(l, "YAML 1.0 ^ tag expansion is not supported")), v;
                                if (/[:/]/.test(v)) {
                                    let w = v.match(/^([a-z0-9-]+)\/(.*)/i);
                                    return w ? `tag:${w[1]}.yaml.org,2002:${w[2]}` : `tag:${v}`;
                                }
                            }
                            return b.prefix + decodeURIComponent(v);
                        }
                        function ve(o, l) {
                            let { tag: _2, type: v } = l, b = false;
                            if (_2) {
                                let { handle: w, suffix: A2, verbatim: N } = _2;
                                if (N) {
                                    if (N !== "!" && N !== "!!") return N;
                                    let j = `Verbatim tags aren't resolved, so ${N} is invalid.`;
                                    o.errors.push(new e.YAMLSemanticError(l, j));
                                } else if (w === "!" && !A2) b = true;
                                else try {
                                    return be(o, l);
                                } catch (j) {
                                    o.errors.push(j);
                                }
                            }
                            switch(v){
                                case e.Type.BLOCK_FOLDED:
                                case e.Type.BLOCK_LITERAL:
                                case e.Type.QUOTE_DOUBLE:
                                case e.Type.QUOTE_SINGLE:
                                    return e.defaultTags.STR;
                                case e.Type.FLOW_MAP:
                                case e.Type.MAP:
                                    return e.defaultTags.MAP;
                                case e.Type.FLOW_SEQ:
                                case e.Type.SEQ:
                                    return e.defaultTags.SEQ;
                                case e.Type.PLAIN:
                                    return b ? e.defaultTags.STR : null;
                                default:
                                    return null;
                            }
                        }
                        function Ne(o, l, _2) {
                            let { tags: v } = o.schema, b = [];
                            for (let A2 of v)if (A2.tag === _2) if (A2.test) b.push(A2);
                            else {
                                let N = A2.resolve(o, l);
                                return N instanceof S ? N : new y(N);
                            }
                            let w = ye(o, l);
                            return typeof w == "string" && b.length > 0 ? u(w, b, v.scalarFallback) : null;
                        }
                        function Pe(o) {
                            let { type: l } = o;
                            switch(l){
                                case e.Type.FLOW_MAP:
                                case e.Type.MAP:
                                    return e.defaultTags.MAP;
                                case e.Type.FLOW_SEQ:
                                case e.Type.SEQ:
                                    return e.defaultTags.SEQ;
                                default:
                                    return e.defaultTags.STR;
                            }
                        }
                        function ot(o, l, _2) {
                            try {
                                let v = Ne(o, l, _2);
                                if (v) return _2 && l.tag && (v.tag = _2), v;
                            } catch (v) {
                                return v.source || (v.source = l), o.errors.push(v), null;
                            }
                            try {
                                let v = Pe(l);
                                if (!v) throw new Error(`The tag ${_2} is unavailable`);
                                let b = `The tag ${_2} is unavailable, falling back to ${v}`;
                                o.warnings.push(new e.YAMLWarning(l, b));
                                let w = Ne(o, l, v);
                                return w.tag = _2, w;
                            } catch (v) {
                                let b = new e.YAMLReferenceError(l, v.message);
                                return b.stack = v.stack, o.errors.push(b), null;
                            }
                        }
                        var lt = (o)=>{
                            if (!o) return false;
                            let { type: l } = o;
                            return l === e.Type.MAP_KEY || l === e.Type.MAP_VALUE || l === e.Type.SEQ_ITEM;
                        };
                        function ct(o, l) {
                            let _2 = {
                                before: [],
                                after: []
                            }, v = false, b = false, w = lt(l.context.parent) ? l.context.parent.props.concat(l.props) : l.props;
                            for (let { start: A2, end: N } of w)switch(l.context.src[A2]){
                                case e.Char.COMMENT:
                                    {
                                        if (!l.commentHasRequiredWhitespace(A2)) {
                                            let H = "Comments must be separated from other tokens by white space characters";
                                            o.push(new e.YAMLSemanticError(l, H));
                                        }
                                        let { header: j, valueRange: F } = l;
                                        (F && (A2 > F.start || j && A2 > j.start) ? _2.after : _2.before).push(l.context.src.slice(A2 + 1, N));
                                        break;
                                    }
                                case e.Char.ANCHOR:
                                    if (v) {
                                        let j = "A node can have at most one anchor";
                                        o.push(new e.YAMLSemanticError(l, j));
                                    }
                                    v = true;
                                    break;
                                case e.Char.TAG:
                                    if (b) {
                                        let j = "A node can have at most one tag";
                                        o.push(new e.YAMLSemanticError(l, j));
                                    }
                                    b = true;
                                    break;
                            }
                            return {
                                comments: _2,
                                hasAnchor: v,
                                hasTag: b
                            };
                        }
                        function ut(o, l) {
                            let { anchors: _2, errors: v, schema: b } = o;
                            if (l.type === e.Type.ALIAS) {
                                let A2 = l.rawValue, N = _2.getNode(A2);
                                if (!N) {
                                    let F = `Aliased anchor not found: ${A2}`;
                                    return v.push(new e.YAMLReferenceError(l, F)), null;
                                }
                                let j = new R(N);
                                return _2._cstAliases.push(j), j;
                            }
                            let w = ve(o, l);
                            if (w) return ot(o, l, w);
                            if (l.type !== e.Type.PLAIN) {
                                let A2 = `Failed to resolve ${l.type} node here`;
                                return v.push(new e.YAMLSyntaxError(l, A2)), null;
                            }
                            try {
                                let A2 = ye(o, l);
                                return u(A2, b.tags, b.tags.scalarFallback);
                            } catch (A2) {
                                return A2.source || (A2.source = l), v.push(A2), null;
                            }
                        }
                        function we(o, l) {
                            if (!l) return null;
                            l.error && o.errors.push(l.error);
                            let { comments: _2, hasAnchor: v, hasTag: b } = ct(o.errors, l);
                            if (v) {
                                let { anchors: A2 } = o, N = l.anchor, j = A2.getNode(N);
                                j && (A2.map[A2.newName(N)] = j), A2.map[N] = l;
                            }
                            if (l.type === e.Type.ALIAS && (v || b)) {
                                let A2 = "An alias node must not specify any properties";
                                o.errors.push(new e.YAMLSemanticError(l, A2));
                            }
                            let w = ut(o, l);
                            if (w) {
                                w.range = [
                                    l.range.start,
                                    l.range.end
                                ], o.options.keepCstNodes && (w.cstNode = l), o.options.keepNodeTypes && (w.type = l.type);
                                let A2 = _2.before.join(`
`);
                                A2 && (w.commentBefore = w.commentBefore ? `${w.commentBefore}
${A2}` : A2);
                                let N = _2.after.join(`
`);
                                N && (w.comment = w.comment ? `${w.comment}
${N}` : N);
                            }
                            return l.resolved = w;
                        }
                        function ft(o, l) {
                            if (l.type !== e.Type.MAP && l.type !== e.Type.FLOW_MAP) {
                                let A2 = `A ${l.type} node cannot be resolved as a mapping`;
                                return o.errors.push(new e.YAMLSyntaxError(l, A2)), null;
                            }
                            let { comments: _2, items: v } = l.type === e.Type.FLOW_MAP ? gt(o, l) : ht(o, l), b = new U();
                            b.items = v, _e(b, _2);
                            let w = false;
                            for(let A2 = 0; A2 < v.length; ++A2){
                                let { key: N } = v[A2];
                                if (N instanceof S && (w = true), o.schema.merge && N && N.value === f2) {
                                    v[A2] = new i(v[A2]);
                                    let j = v[A2].value.items, F = null;
                                    j.some((Q)=>{
                                        if (Q instanceof R) {
                                            let { type: H } = Q.source;
                                            return H === e.Type.MAP || H === e.Type.FLOW_MAP ? false : F = "Merge nodes aliases can only point to maps";
                                        }
                                        return F = "Merge nodes can only have Alias nodes as values";
                                    }), F && o.errors.push(new e.YAMLSemanticError(l, F));
                                } else for(let j = A2 + 1; j < v.length; ++j){
                                    let { key: F } = v[j];
                                    if (N === F || N && F && Object.prototype.hasOwnProperty.call(N, "value") && N.value === F.value) {
                                        let Q = `Map keys must be unique; "${N}" is repeated`;
                                        o.errors.push(new e.YAMLSemanticError(l, Q));
                                        break;
                                    }
                                }
                            }
                            if (w && !o.options.mapAsMap) {
                                let A2 = "Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.";
                                o.warnings.push(new e.YAMLWarning(l, A2));
                            }
                            return l.resolved = b, b;
                        }
                        var mt = (o)=>{
                            let { context: { lineStart: l, node: _2, src: v }, props: b } = o;
                            if (b.length === 0) return false;
                            let { start: w } = b[0];
                            if (_2 && w > _2.valueRange.start || v[w] !== e.Char.COMMENT) return false;
                            for(let A2 = l; A2 < w; ++A2)if (v[A2] === `
`) return false;
                            return true;
                        };
                        function dt(o, l) {
                            if (!mt(o)) return;
                            let _2 = o.getPropValue(0, e.Char.COMMENT, true), v = false, b = l.value.commentBefore;
                            if (b && b.startsWith(_2)) l.value.commentBefore = b.substr(_2.length + 1), v = true;
                            else {
                                let w = l.value.comment;
                                !o.node && w && w.startsWith(_2) && (l.value.comment = w.substr(_2.length + 1), v = true);
                            }
                            v && (l.comment = _2);
                        }
                        function ht(o, l) {
                            let _2 = [], v = [], b, w = null;
                            for(let A2 = 0; A2 < l.items.length; ++A2){
                                let N = l.items[A2];
                                switch(N.type){
                                    case e.Type.BLANK_LINE:
                                        _2.push({
                                            afterKey: !!b,
                                            before: v.length
                                        });
                                        break;
                                    case e.Type.COMMENT:
                                        _2.push({
                                            afterKey: !!b,
                                            before: v.length,
                                            comment: N.comment
                                        });
                                        break;
                                    case e.Type.MAP_KEY:
                                        b !== void 0 && v.push(new C(b)), N.error && o.errors.push(N.error), b = we(o, N.node), w = null;
                                        break;
                                    case e.Type.MAP_VALUE:
                                        {
                                            if (b === void 0 && (b = null), N.error && o.errors.push(N.error), !N.context.atLineStart && N.node && N.node.type === e.Type.MAP && !N.node.context.atLineStart) {
                                                let Q = "Nested mappings are not allowed in compact mappings";
                                                o.errors.push(new e.YAMLSemanticError(N.node, Q));
                                            }
                                            let j = N.node;
                                            if (!j && N.props.length > 0) {
                                                j = new e.PlainValue(e.Type.PLAIN, []), j.context = {
                                                    parent: N,
                                                    src: N.context.src
                                                };
                                                let Q = N.range.start + 1;
                                                if (j.range = {
                                                    start: Q,
                                                    end: Q
                                                }, j.valueRange = {
                                                    start: Q,
                                                    end: Q
                                                }, typeof N.range.origStart == "number") {
                                                    let H = N.range.origStart + 1;
                                                    j.range.origStart = j.range.origEnd = H, j.valueRange.origStart = j.valueRange.origEnd = H;
                                                }
                                            }
                                            let F = new C(b, we(o, j));
                                            dt(N, F), v.push(F), b && typeof w == "number" && N.range.start > w + 1024 && o.errors.push(re(l, b)), b = void 0, w = null;
                                        }
                                        break;
                                    default:
                                        b !== void 0 && v.push(new C(b)), b = we(o, N), w = N.range.start, N.error && o.errors.push(N.error);
                                        e: for(let j = A2 + 1;; ++j){
                                            let F = l.items[j];
                                            switch(F && F.type){
                                                case e.Type.BLANK_LINE:
                                                case e.Type.COMMENT:
                                                    continue e;
                                                case e.Type.MAP_VALUE:
                                                    break e;
                                                default:
                                                    {
                                                        let Q = "Implicit map keys need to be followed by map values";
                                                        o.errors.push(new e.YAMLSemanticError(N, Q));
                                                        break e;
                                                    }
                                            }
                                        }
                                        if (N.valueRangeContainsNewline) {
                                            let j = "Implicit map keys need to be on a single line";
                                            o.errors.push(new e.YAMLSemanticError(N, j));
                                        }
                                }
                            }
                            return b !== void 0 && v.push(new C(b)), {
                                comments: _2,
                                items: v
                            };
                        }
                        function gt(o, l) {
                            let _2 = [], v = [], b, w = false, A2 = "{";
                            for(let N = 0; N < l.items.length; ++N){
                                let j = l.items[N];
                                if (typeof j.char == "string") {
                                    let { char: F, offset: Q } = j;
                                    if (F === "?" && b === void 0 && !w) {
                                        w = true, A2 = ":";
                                        continue;
                                    }
                                    if (F === ":") {
                                        if (b === void 0 && (b = null), A2 === ":") {
                                            A2 = ",";
                                            continue;
                                        }
                                    } else if (w && (b === void 0 && F !== "," && (b = null), w = false), b !== void 0 && (v.push(new C(b)), b = void 0, F === ",")) {
                                        A2 = ":";
                                        continue;
                                    }
                                    if (F === "}") {
                                        if (N === l.items.length - 1) continue;
                                    } else if (F === A2) {
                                        A2 = ":";
                                        continue;
                                    }
                                    let H = `Flow map contains an unexpected ${F}`, oe = new e.YAMLSyntaxError(l, H);
                                    oe.offset = Q, o.errors.push(oe);
                                } else j.type === e.Type.BLANK_LINE ? _2.push({
                                    afterKey: !!b,
                                    before: v.length
                                }) : j.type === e.Type.COMMENT ? (G(o.errors, j), _2.push({
                                    afterKey: !!b,
                                    before: v.length,
                                    comment: j.comment
                                })) : b === void 0 ? (A2 === "," && o.errors.push(new e.YAMLSemanticError(j, "Separator , missing in flow map")), b = we(o, j)) : (A2 !== "," && o.errors.push(new e.YAMLSemanticError(j, "Indicator : missing in flow map entry")), v.push(new C(b, we(o, j))), b = void 0, w = false);
                            }
                            return x(o.errors, l), b !== void 0 && v.push(new C(b)), {
                                comments: _2,
                                items: v
                            };
                        }
                        function pt(o, l) {
                            if (l.type !== e.Type.SEQ && l.type !== e.Type.FLOW_SEQ) {
                                let w = `A ${l.type} node cannot be resolved as a sequence`;
                                return o.errors.push(new e.YAMLSyntaxError(l, w)), null;
                            }
                            let { comments: _2, items: v } = l.type === e.Type.FLOW_SEQ ? vt(o, l) : _t(o, l), b = new T();
                            if (b.items = v, _e(b, _2), !o.options.mapAsMap && v.some((w)=>w instanceof C && w.key instanceof S)) {
                                let w = "Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.";
                                o.warnings.push(new e.YAMLWarning(l, w));
                            }
                            return l.resolved = b, b;
                        }
                        function _t(o, l) {
                            let _2 = [], v = [];
                            for(let b = 0; b < l.items.length; ++b){
                                let w = l.items[b];
                                switch(w.type){
                                    case e.Type.BLANK_LINE:
                                        _2.push({
                                            before: v.length
                                        });
                                        break;
                                    case e.Type.COMMENT:
                                        _2.push({
                                            comment: w.comment,
                                            before: v.length
                                        });
                                        break;
                                    case e.Type.SEQ_ITEM:
                                        if (w.error && o.errors.push(w.error), v.push(we(o, w.node)), w.hasProps) {
                                            let A2 = "Sequence items cannot have tags or anchors before the - indicator";
                                            o.errors.push(new e.YAMLSemanticError(w, A2));
                                        }
                                        break;
                                    default:
                                        w.error && o.errors.push(w.error), o.errors.push(new e.YAMLSyntaxError(w, `Unexpected ${w.type} node in sequence`));
                                }
                            }
                            return {
                                comments: _2,
                                items: v
                            };
                        }
                        function vt(o, l) {
                            let _2 = [], v = [], b = false, w, A2 = null, N = "[", j = null;
                            for(let F = 0; F < l.items.length; ++F){
                                let Q = l.items[F];
                                if (typeof Q.char == "string") {
                                    let { char: H, offset: oe } = Q;
                                    if (H !== ":" && (b || w !== void 0) && (b && w === void 0 && (w = N ? v.pop() : null), v.push(new C(w)), b = false, w = void 0, A2 = null), H === N) N = null;
                                    else if (!N && H === "?") b = true;
                                    else if (N !== "[" && H === ":" && w === void 0) {
                                        if (N === ",") {
                                            if (w = v.pop(), w instanceof C) {
                                                let le = "Chaining flow sequence pairs is invalid", Z = new e.YAMLSemanticError(l, le);
                                                Z.offset = oe, o.errors.push(Z);
                                            }
                                            if (!b && typeof A2 == "number") {
                                                let le = Q.range ? Q.range.start : Q.offset;
                                                le > A2 + 1024 && o.errors.push(re(l, w));
                                                let { src: Z } = j.context;
                                                for(let ee = A2; ee < le; ++ee)if (Z[ee] === `
`) {
                                                    let X = "Implicit keys of flow sequence pairs need to be on a single line";
                                                    o.errors.push(new e.YAMLSemanticError(j, X));
                                                    break;
                                                }
                                            }
                                        } else w = null;
                                        A2 = null, b = false, N = null;
                                    } else if (N === "[" || H !== "]" || F < l.items.length - 1) {
                                        let le = `Flow sequence contains an unexpected ${H}`, Z = new e.YAMLSyntaxError(l, le);
                                        Z.offset = oe, o.errors.push(Z);
                                    }
                                } else if (Q.type === e.Type.BLANK_LINE) _2.push({
                                    before: v.length
                                });
                                else if (Q.type === e.Type.COMMENT) G(o.errors, Q), _2.push({
                                    comment: Q.comment,
                                    before: v.length
                                });
                                else {
                                    if (N) {
                                        let oe = `Expected a ${N} in flow sequence`;
                                        o.errors.push(new e.YAMLSemanticError(Q, oe));
                                    }
                                    let H = we(o, Q);
                                    w === void 0 ? (v.push(H), j = Q) : (v.push(new C(w, H)), w = void 0), A2 = Q.range.start, N = ",";
                                }
                            }
                            return x(o.errors, l), w !== void 0 && v.push(new C(w)), {
                                comments: _2,
                                items: v
                            };
                        }
                        n.Alias = R, n.Collection = S, n.Merge = i, n.Node = h, n.Pair = C, n.Scalar = y, n.YAMLMap = U, n.YAMLSeq = T, n.addComment = c, n.binaryOptions = t1, n.boolOptions = s, n.findPair = B, n.intOptions = a2, n.isEmptyPath = I, n.nullOptions = m, n.resolveMap = ft, n.resolveNode = we, n.resolveSeq = pt, n.resolveString = ye, n.strOptions = g, n.stringifyNumber = J, n.stringifyString = W, n.toJSON = d;
                    }
                }), st = D({
                    "node_modules/yaml/dist/warnings-1000a372.js" (n) {
                        "use strict";
                        Y();
                        var e = Me(), r = ke(), c = {
                            identify: (u)=>u instanceof Uint8Array,
                            default: false,
                            tag: "tag:yaml.org,2002:binary",
                            resolve: (u, p)=>{
                                let L = r.resolveString(u, p);
                                if (typeof Buffer == "function") return Buffer.from(L, "base64");
                                if (typeof atob == "function") {
                                    let k = atob(L.replace(/[\n\r]/g, "")), $ = new Uint8Array(k.length);
                                    for(let K = 0; K < k.length; ++K)$[K] = k.charCodeAt(K);
                                    return $;
                                } else {
                                    let k = "This environment does not support reading binary tags; either Buffer or atob is required";
                                    return u.errors.push(new e.YAMLReferenceError(p, k)), null;
                                }
                            },
                            options: r.binaryOptions,
                            stringify: (u, p, L, k)=>{
                                let { comment: $, type: K, value: V } = u, z;
                                if (typeof Buffer == "function") z = V instanceof Buffer ? V.toString("base64") : Buffer.from(V.buffer).toString("base64");
                                else if (typeof btoa == "function") {
                                    let ae = "";
                                    for(let ue = 0; ue < V.length; ++ue)ae += String.fromCharCode(V[ue]);
                                    z = btoa(ae);
                                } else throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required");
                                if (K || (K = r.binaryOptions.defaultType), K === e.Type.QUOTE_DOUBLE) V = z;
                                else {
                                    let { lineWidth: ae } = r.binaryOptions, ue = Math.ceil(z.length / ae), pe = new Array(ue);
                                    for(let ge = 0, O = 0; ge < ue; ++ge, O += ae)pe[ge] = z.substr(O, ae);
                                    V = pe.join(K === e.Type.BLOCK_LITERAL ? `
` : " ");
                                }
                                return r.stringifyString({
                                    comment: $,
                                    type: K,
                                    value: V
                                }, p, L, k);
                            }
                        };
                        function h(u, p) {
                            let L = r.resolveSeq(u, p);
                            for(let k = 0; k < L.items.length; ++k){
                                let $ = L.items[k];
                                if (!($ instanceof r.Pair)) {
                                    if ($ instanceof r.YAMLMap) {
                                        if ($.items.length > 1) {
                                            let V = "Each pair must have its own sequence indicator";
                                            throw new e.YAMLSemanticError(p, V);
                                        }
                                        let K = $.items[0] || new r.Pair();
                                        $.commentBefore && (K.commentBefore = K.commentBefore ? `${$.commentBefore}
${K.commentBefore}` : $.commentBefore), $.comment && (K.comment = K.comment ? `${$.comment}
${K.comment}` : $.comment), $ = K;
                                    }
                                    L.items[k] = $ instanceof r.Pair ? $ : new r.Pair($);
                                }
                            }
                            return L;
                        }
                        function d(u, p, L) {
                            let k = new r.YAMLSeq(u);
                            k.tag = "tag:yaml.org,2002:pairs";
                            for (let $ of p){
                                let K, V;
                                if (Array.isArray($)) if ($.length === 2) K = $[0], V = $[1];
                                else throw new TypeError(`Expected [key, value] tuple: ${$}`);
                                else if ($ && $ instanceof Object) {
                                    let ae = Object.keys($);
                                    if (ae.length === 1) K = ae[0], V = $[K];
                                    else throw new TypeError(`Expected { key: value } tuple: ${$}`);
                                } else K = $;
                                let z = u.createPair(K, V, L);
                                k.items.push(z);
                            }
                            return k;
                        }
                        var y = {
                            default: false,
                            tag: "tag:yaml.org,2002:pairs",
                            resolve: h,
                            createNode: d
                        }, E = class extends r.YAMLSeq {
                            toJSON(u, p) {
                                let L = /* @__PURE__ */ new Map();
                                p && p.onCreate && p.onCreate(L);
                                for (let k of this.items){
                                    let $, K;
                                    if (k instanceof r.Pair ? ($ = r.toJSON(k.key, "", p), K = r.toJSON(k.value, $, p)) : $ = r.toJSON(k, "", p), L.has($)) throw new Error("Ordered maps must not include duplicate keys");
                                    L.set($, K);
                                }
                                return L;
                            }
                            constructor(){
                                super(), e._defineProperty(this, "add", r.YAMLMap.prototype.add.bind(this)), e._defineProperty(this, "delete", r.YAMLMap.prototype.delete.bind(this)), e._defineProperty(this, "get", r.YAMLMap.prototype.get.bind(this)), e._defineProperty(this, "has", r.YAMLMap.prototype.has.bind(this)), e._defineProperty(this, "set", r.YAMLMap.prototype.set.bind(this)), this.tag = E.tag;
                            }
                        };
                        e._defineProperty(E, "tag", "tag:yaml.org,2002:omap");
                        function I(u, p) {
                            let L = h(u, p), k = [];
                            for (let { key: $ } of L.items)if ($ instanceof r.Scalar) if (k.includes($.value)) {
                                let K = "Ordered maps must not include duplicate keys";
                                throw new e.YAMLSemanticError(p, K);
                            } else k.push($.value);
                            return Object.assign(new E(), L);
                        }
                        function S(u, p, L) {
                            let k = d(u, p, L), $ = new E();
                            return $.items = k.items, $;
                        }
                        var M = {
                            identify: (u)=>u instanceof Map,
                            nodeClass: E,
                            default: false,
                            tag: "tag:yaml.org,2002:omap",
                            resolve: I,
                            createNode: S
                        }, T = class extends r.YAMLMap {
                            add(u) {
                                let p = u instanceof r.Pair ? u : new r.Pair(u);
                                r.findPair(this.items, p.key) || this.items.push(p);
                            }
                            get(u, p) {
                                let L = r.findPair(this.items, u);
                                return !p && L instanceof r.Pair ? L.key instanceof r.Scalar ? L.key.value : L.key : L;
                            }
                            set(u, p) {
                                if (typeof p != "boolean") throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof p}`);
                                let L = r.findPair(this.items, u);
                                L && !p ? this.items.splice(this.items.indexOf(L), 1) : !L && p && this.items.push(new r.Pair(u));
                            }
                            toJSON(u, p) {
                                return super.toJSON(u, p, Set);
                            }
                            toString(u, p, L) {
                                if (!u) return JSON.stringify(this);
                                if (this.hasAllNullValues()) return super.toString(u, p, L);
                                throw new Error("Set items must all have null values");
                            }
                            constructor(){
                                super(), this.tag = T.tag;
                            }
                        };
                        e._defineProperty(T, "tag", "tag:yaml.org,2002:set");
                        function P(u, p) {
                            let L = r.resolveMap(u, p);
                            if (!L.hasAllNullValues()) throw new e.YAMLSemanticError(p, "Set items must all have null values");
                            return Object.assign(new T(), L);
                        }
                        function C(u, p, L) {
                            let k = new T();
                            for (let $ of p)k.items.push(u.createPair($, null, L));
                            return k;
                        }
                        var q = {
                            identify: (u)=>u instanceof Set,
                            nodeClass: T,
                            default: false,
                            tag: "tag:yaml.org,2002:set",
                            resolve: P,
                            createNode: C
                        }, R = (u, p)=>{
                            let L = p.split(":").reduce((k, $)=>k * 60 + Number($), 0);
                            return u === "-" ? -L : L;
                        }, B = (u)=>{
                            let { value: p } = u;
                            if (isNaN(p) || !isFinite(p)) return r.stringifyNumber(p);
                            let L = "";
                            p < 0 && (L = "-", p = Math.abs(p));
                            let k = [
                                p % 60
                            ];
                            return p < 60 ? k.unshift(0) : (p = Math.round((p - k[0]) / 60), k.unshift(p % 60), p >= 60 && (p = Math.round((p - k[0]) / 60), k.unshift(p))), L + k.map(($)=>$ < 10 ? "0" + String($) : String($)).join(":").replace(/000000\d*$/, "");
                        }, U = {
                            identify: (u)=>typeof u == "number",
                            default: true,
                            tag: "tag:yaml.org,2002:int",
                            format: "TIME",
                            test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+)$/,
                            resolve: (u, p, L)=>R(p, L.replace(/_/g, "")),
                            stringify: B
                        }, f2 = {
                            identify: (u)=>typeof u == "number",
                            default: true,
                            tag: "tag:yaml.org,2002:float",
                            format: "TIME",
                            test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*)$/,
                            resolve: (u, p, L)=>R(p, L.replace(/_/g, "")),
                            stringify: B
                        }, i = {
                            identify: (u)=>u instanceof Date,
                            default: true,
                            tag: "tag:yaml.org,2002:timestamp",
                            test: RegExp("^(?:([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?)$"),
                            resolve: (u, p, L, k, $, K, V, z, ae)=>{
                                z && (z = (z + "00").substr(1, 3));
                                let ue = Date.UTC(p, L - 1, k, $ || 0, K || 0, V || 0, z || 0);
                                if (ae && ae !== "Z") {
                                    let pe = R(ae[0], ae.slice(1));
                                    Math.abs(pe) < 30 && (pe *= 60), ue -= 6e4 * pe;
                                }
                                return new Date(ue);
                            },
                            stringify: (u)=>{
                                let { value: p } = u;
                                return p.toISOString().replace(/((T00:00)?:00)?\.000Z$/, "");
                            }
                        };
                        function t1(u) {
                            let p = typeof Te < "u" && Te.env || {};
                            return u ? typeof YAML_SILENCE_DEPRECATION_WARNINGS < "u" ? !YAML_SILENCE_DEPRECATION_WARNINGS : !p.YAML_SILENCE_DEPRECATION_WARNINGS : typeof YAML_SILENCE_WARNINGS < "u" ? !YAML_SILENCE_WARNINGS : !p.YAML_SILENCE_WARNINGS;
                        }
                        function s(u, p) {
                            if (t1(false)) {
                                let L = typeof Te < "u" && Te.emitWarning;
                                L ? L(u, p) : console.warn(p ? `${p}: ${u}` : u);
                            }
                        }
                        function a2(u) {
                            if (t1(true)) {
                                let p = u.replace(/.*yaml[/\\]/i, "").replace(/\.js$/, "").replace(/\\/g, "/");
                                s(`The endpoint 'yaml/${p}' will be removed in a future release.`, "DeprecationWarning");
                            }
                        }
                        var m = {};
                        function g(u, p) {
                            if (!m[u] && t1(true)) {
                                m[u] = true;
                                let L = `The option '${u}' will be removed in a future release`;
                                L += p ? `, use '${p}' instead.` : ".", s(L, "DeprecationWarning");
                            }
                        }
                        n.binary = c, n.floatTime = f2, n.intTime = U, n.omap = M, n.pairs = y, n.set = q, n.timestamp = i, n.warn = s, n.warnFileDeprecation = a2, n.warnOptionDeprecation = g;
                    }
                }), it = D({
                    "node_modules/yaml/dist/Schema-88e323a7.js" (n) {
                        "use strict";
                        Y();
                        var e = Me(), r = ke(), c = st();
                        function h(O, W, J) {
                            let x = new r.YAMLMap(O);
                            if (W instanceof Map) for (let [G, re] of W)x.items.push(O.createPair(G, re, J));
                            else if (W && typeof W == "object") for (let G of Object.keys(W))x.items.push(O.createPair(G, W[G], J));
                            return typeof O.sortMapEntries == "function" && x.items.sort(O.sortMapEntries), x;
                        }
                        var d = {
                            createNode: h,
                            default: true,
                            nodeClass: r.YAMLMap,
                            tag: "tag:yaml.org,2002:map",
                            resolve: r.resolveMap
                        };
                        function y(O, W, J) {
                            let x = new r.YAMLSeq(O);
                            if (W && W[Symbol.iterator]) for (let G of W){
                                let re = O.createNode(G, J.wrapScalars, null, J);
                                x.items.push(re);
                            }
                            return x;
                        }
                        var E = {
                            createNode: y,
                            default: true,
                            nodeClass: r.YAMLSeq,
                            tag: "tag:yaml.org,2002:seq",
                            resolve: r.resolveSeq
                        }, I = {
                            identify: (O)=>typeof O == "string",
                            default: true,
                            tag: "tag:yaml.org,2002:str",
                            resolve: r.resolveString,
                            stringify (O, W, J, x) {
                                return W = Object.assign({
                                    actualString: true
                                }, W), r.stringifyString(O, W, J, x);
                            },
                            options: r.strOptions
                        }, S = [
                            d,
                            E,
                            I
                        ], M = (O)=>typeof O == "bigint" || Number.isInteger(O), T = (O, W, J)=>r.intOptions.asBigInt ? BigInt(O) : parseInt(W, J);
                        function P(O, W, J) {
                            let { value: x } = O;
                            return M(x) && x >= 0 ? J + x.toString(W) : r.stringifyNumber(O);
                        }
                        var C = {
                            identify: (O)=>O == null,
                            createNode: (O, W, J)=>J.wrapScalars ? new r.Scalar(null) : null,
                            default: true,
                            tag: "tag:yaml.org,2002:null",
                            test: /^(?:~|[Nn]ull|NULL)?$/,
                            resolve: ()=>null,
                            options: r.nullOptions,
                            stringify: ()=>r.nullOptions.nullStr
                        }, q = {
                            identify: (O)=>typeof O == "boolean",
                            default: true,
                            tag: "tag:yaml.org,2002:bool",
                            test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
                            resolve: (O)=>O[0] === "t" || O[0] === "T",
                            options: r.boolOptions,
                            stringify: (O)=>{
                                let { value: W } = O;
                                return W ? r.boolOptions.trueStr : r.boolOptions.falseStr;
                            }
                        }, R = {
                            identify: (O)=>M(O) && O >= 0,
                            default: true,
                            tag: "tag:yaml.org,2002:int",
                            format: "OCT",
                            test: /^0o([0-7]+)$/,
                            resolve: (O, W)=>T(O, W, 8),
                            options: r.intOptions,
                            stringify: (O)=>P(O, 8, "0o")
                        }, B = {
                            identify: M,
                            default: true,
                            tag: "tag:yaml.org,2002:int",
                            test: /^[-+]?[0-9]+$/,
                            resolve: (O)=>T(O, O, 10),
                            options: r.intOptions,
                            stringify: r.stringifyNumber
                        }, U = {
                            identify: (O)=>M(O) && O >= 0,
                            default: true,
                            tag: "tag:yaml.org,2002:int",
                            format: "HEX",
                            test: /^0x([0-9a-fA-F]+)$/,
                            resolve: (O, W)=>T(O, W, 16),
                            options: r.intOptions,
                            stringify: (O)=>P(O, 16, "0x")
                        }, f2 = {
                            identify: (O)=>typeof O == "number",
                            default: true,
                            tag: "tag:yaml.org,2002:float",
                            test: /^(?:[-+]?\.inf|(\.nan))$/i,
                            resolve: (O, W)=>W ? NaN : O[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
                            stringify: r.stringifyNumber
                        }, i = {
                            identify: (O)=>typeof O == "number",
                            default: true,
                            tag: "tag:yaml.org,2002:float",
                            format: "EXP",
                            test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
                            resolve: (O)=>parseFloat(O),
                            stringify: (O)=>{
                                let { value: W } = O;
                                return Number(W).toExponential();
                            }
                        }, t1 = {
                            identify: (O)=>typeof O == "number",
                            default: true,
                            tag: "tag:yaml.org,2002:float",
                            test: /^[-+]?(?:\.([0-9]+)|[0-9]+\.([0-9]*))$/,
                            resolve (O, W, J) {
                                let x = W || J, G = new r.Scalar(parseFloat(O));
                                return x && x[x.length - 1] === "0" && (G.minFractionDigits = x.length), G;
                            },
                            stringify: r.stringifyNumber
                        }, s = S.concat([
                            C,
                            q,
                            R,
                            B,
                            U,
                            f2,
                            i,
                            t1
                        ]), a2 = (O)=>typeof O == "bigint" || Number.isInteger(O), m = (O)=>{
                            let { value: W } = O;
                            return JSON.stringify(W);
                        }, g = [
                            d,
                            E,
                            {
                                identify: (O)=>typeof O == "string",
                                default: true,
                                tag: "tag:yaml.org,2002:str",
                                resolve: r.resolveString,
                                stringify: m
                            },
                            {
                                identify: (O)=>O == null,
                                createNode: (O, W, J)=>J.wrapScalars ? new r.Scalar(null) : null,
                                default: true,
                                tag: "tag:yaml.org,2002:null",
                                test: /^null$/,
                                resolve: ()=>null,
                                stringify: m
                            },
                            {
                                identify: (O)=>typeof O == "boolean",
                                default: true,
                                tag: "tag:yaml.org,2002:bool",
                                test: /^true|false$/,
                                resolve: (O)=>O === "true",
                                stringify: m
                            },
                            {
                                identify: a2,
                                default: true,
                                tag: "tag:yaml.org,2002:int",
                                test: /^-?(?:0|[1-9][0-9]*)$/,
                                resolve: (O)=>r.intOptions.asBigInt ? BigInt(O) : parseInt(O, 10),
                                stringify: (O)=>{
                                    let { value: W } = O;
                                    return a2(W) ? W.toString() : JSON.stringify(W);
                                }
                            },
                            {
                                identify: (O)=>typeof O == "number",
                                default: true,
                                tag: "tag:yaml.org,2002:float",
                                test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
                                resolve: (O)=>parseFloat(O),
                                stringify: m
                            }
                        ];
                        g.scalarFallback = (O)=>{
                            throw new SyntaxError(`Unresolved plain scalar ${JSON.stringify(O)}`);
                        };
                        var u = (O)=>{
                            let { value: W } = O;
                            return W ? r.boolOptions.trueStr : r.boolOptions.falseStr;
                        }, p = (O)=>typeof O == "bigint" || Number.isInteger(O);
                        function L(O, W, J) {
                            let x = W.replace(/_/g, "");
                            if (r.intOptions.asBigInt) {
                                switch(J){
                                    case 2:
                                        x = `0b${x}`;
                                        break;
                                    case 8:
                                        x = `0o${x}`;
                                        break;
                                    case 16:
                                        x = `0x${x}`;
                                        break;
                                }
                                let re = BigInt(x);
                                return O === "-" ? BigInt(-1) * re : re;
                            }
                            let G = parseInt(x, J);
                            return O === "-" ? -1 * G : G;
                        }
                        function k(O, W, J) {
                            let { value: x } = O;
                            if (p(x)) {
                                let G = x.toString(W);
                                return x < 0 ? "-" + J + G.substr(1) : J + G;
                            }
                            return r.stringifyNumber(O);
                        }
                        var $ = S.concat([
                            {
                                identify: (O)=>O == null,
                                createNode: (O, W, J)=>J.wrapScalars ? new r.Scalar(null) : null,
                                default: true,
                                tag: "tag:yaml.org,2002:null",
                                test: /^(?:~|[Nn]ull|NULL)?$/,
                                resolve: ()=>null,
                                options: r.nullOptions,
                                stringify: ()=>r.nullOptions.nullStr
                            },
                            {
                                identify: (O)=>typeof O == "boolean",
                                default: true,
                                tag: "tag:yaml.org,2002:bool",
                                test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
                                resolve: ()=>true,
                                options: r.boolOptions,
                                stringify: u
                            },
                            {
                                identify: (O)=>typeof O == "boolean",
                                default: true,
                                tag: "tag:yaml.org,2002:bool",
                                test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,
                                resolve: ()=>false,
                                options: r.boolOptions,
                                stringify: u
                            },
                            {
                                identify: p,
                                default: true,
                                tag: "tag:yaml.org,2002:int",
                                format: "BIN",
                                test: /^([-+]?)0b([0-1_]+)$/,
                                resolve: (O, W, J)=>L(W, J, 2),
                                stringify: (O)=>k(O, 2, "0b")
                            },
                            {
                                identify: p,
                                default: true,
                                tag: "tag:yaml.org,2002:int",
                                format: "OCT",
                                test: /^([-+]?)0([0-7_]+)$/,
                                resolve: (O, W, J)=>L(W, J, 8),
                                stringify: (O)=>k(O, 8, "0")
                            },
                            {
                                identify: p,
                                default: true,
                                tag: "tag:yaml.org,2002:int",
                                test: /^([-+]?)([0-9][0-9_]*)$/,
                                resolve: (O, W, J)=>L(W, J, 10),
                                stringify: r.stringifyNumber
                            },
                            {
                                identify: p,
                                default: true,
                                tag: "tag:yaml.org,2002:int",
                                format: "HEX",
                                test: /^([-+]?)0x([0-9a-fA-F_]+)$/,
                                resolve: (O, W, J)=>L(W, J, 16),
                                stringify: (O)=>k(O, 16, "0x")
                            },
                            {
                                identify: (O)=>typeof O == "number",
                                default: true,
                                tag: "tag:yaml.org,2002:float",
                                test: /^(?:[-+]?\.inf|(\.nan))$/i,
                                resolve: (O, W)=>W ? NaN : O[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
                                stringify: r.stringifyNumber
                            },
                            {
                                identify: (O)=>typeof O == "number",
                                default: true,
                                tag: "tag:yaml.org,2002:float",
                                format: "EXP",
                                test: /^[-+]?([0-9][0-9_]*)?(\.[0-9_]*)?[eE][-+]?[0-9]+$/,
                                resolve: (O)=>parseFloat(O.replace(/_/g, "")),
                                stringify: (O)=>{
                                    let { value: W } = O;
                                    return Number(W).toExponential();
                                }
                            },
                            {
                                identify: (O)=>typeof O == "number",
                                default: true,
                                tag: "tag:yaml.org,2002:float",
                                test: /^[-+]?(?:[0-9][0-9_]*)?\.([0-9_]*)$/,
                                resolve (O, W) {
                                    let J = new r.Scalar(parseFloat(O.replace(/_/g, "")));
                                    if (W) {
                                        let x = W.replace(/_/g, "");
                                        x[x.length - 1] === "0" && (J.minFractionDigits = x.length);
                                    }
                                    return J;
                                },
                                stringify: r.stringifyNumber
                            }
                        ], c.binary, c.omap, c.pairs, c.set, c.intTime, c.floatTime, c.timestamp), K = {
                            core: s,
                            failsafe: S,
                            json: g,
                            yaml11: $
                        }, V = {
                            binary: c.binary,
                            bool: q,
                            float: t1,
                            floatExp: i,
                            floatNaN: f2,
                            floatTime: c.floatTime,
                            int: B,
                            intHex: U,
                            intOct: R,
                            intTime: c.intTime,
                            map: d,
                            null: C,
                            omap: c.omap,
                            pairs: c.pairs,
                            seq: E,
                            set: c.set,
                            timestamp: c.timestamp
                        };
                        function z(O, W, J) {
                            if (W) {
                                let x = J.filter((re)=>re.tag === W), G = x.find((re)=>!re.format) || x[0];
                                if (!G) throw new Error(`Tag ${W} not found`);
                                return G;
                            }
                            return J.find((x)=>(x.identify && x.identify(O) || x.class && O instanceof x.class) && !x.format);
                        }
                        function ae(O, W, J) {
                            if (O instanceof r.Node) return O;
                            let { defaultPrefix: x, onTagObj: G, prevObjects: re, schema: _e, wrapScalars: ye } = J;
                            W && W.startsWith("!!") && (W = x + W.slice(2));
                            let be = z(O, W, _e.tags);
                            if (!be) {
                                if (typeof O.toJSON == "function" && (O = O.toJSON()), !O || typeof O != "object") return ye ? new r.Scalar(O) : O;
                                be = O instanceof Map ? d : O[Symbol.iterator] ? E : d;
                            }
                            G && (G(be), delete J.onTagObj);
                            let ve = {
                                value: void 0,
                                node: void 0
                            };
                            if (O && typeof O == "object" && re) {
                                let Ne = re.get(O);
                                if (Ne) {
                                    let Pe = new r.Alias(Ne);
                                    return J.aliasNodes.push(Pe), Pe;
                                }
                                ve.value = O, re.set(O, ve);
                            }
                            return ve.node = be.createNode ? be.createNode(J.schema, O, J) : ye ? new r.Scalar(O) : O, W && ve.node instanceof r.Node && (ve.node.tag = W), ve.node;
                        }
                        function ue(O, W, J, x) {
                            let G = O[x.replace(/\W/g, "")];
                            if (!G) {
                                let re = Object.keys(O).map((_e)=>JSON.stringify(_e)).join(", ");
                                throw new Error(`Unknown schema "${x}"; use one of ${re}`);
                            }
                            if (Array.isArray(J)) for (let re of J)G = G.concat(re);
                            else typeof J == "function" && (G = J(G.slice()));
                            for(let re = 0; re < G.length; ++re){
                                let _e = G[re];
                                if (typeof _e == "string") {
                                    let ye = W[_e];
                                    if (!ye) {
                                        let be = Object.keys(W).map((ve)=>JSON.stringify(ve)).join(", ");
                                        throw new Error(`Unknown custom tag "${_e}"; use one of ${be}`);
                                    }
                                    G[re] = ye;
                                }
                            }
                            return G;
                        }
                        var pe = (O, W)=>O.key < W.key ? -1 : O.key > W.key ? 1 : 0, ge = class {
                            createNode(O, W, J, x) {
                                let G = {
                                    defaultPrefix: ge.defaultPrefix,
                                    schema: this,
                                    wrapScalars: W
                                }, re = x ? Object.assign(x, G) : G;
                                return ae(O, J, re);
                            }
                            createPair(O, W, J) {
                                J || (J = {
                                    wrapScalars: true
                                });
                                let x = this.createNode(O, J.wrapScalars, null, J), G = this.createNode(W, J.wrapScalars, null, J);
                                return new r.Pair(x, G);
                            }
                            constructor(O){
                                let { customTags: W, merge: J, schema: x, sortMapEntries: G, tags: re } = O;
                                this.merge = !!J, this.name = x, this.sortMapEntries = G === true ? pe : G || null, !W && re && c.warnOptionDeprecation("tags", "customTags"), this.tags = ue(K, V, W || re, x);
                            }
                        };
                        e._defineProperty(ge, "defaultPrefix", e.defaultTagPrefix), e._defineProperty(ge, "defaultTags", e.defaultTags), n.Schema = ge;
                    }
                }), xr = D({
                    "node_modules/yaml/dist/Document-9b4560a1.js" (n) {
                        "use strict";
                        Y();
                        var e = Me(), r = ke(), c = it(), h = {
                            anchorPrefix: "a",
                            customTags: null,
                            indent: 2,
                            indentSeq: true,
                            keepCstNodes: false,
                            keepNodeTypes: true,
                            keepBlobsInJSON: true,
                            mapAsMap: false,
                            maxAliasCount: 100,
                            prettyErrors: false,
                            simpleKeys: false,
                            version: "1.2"
                        }, d = {
                            get binary () {
                                return r.binaryOptions;
                            },
                            set binary (t){
                                Object.assign(r.binaryOptions, t);
                            },
                            get bool () {
                                return r.boolOptions;
                            },
                            set bool (t){
                                Object.assign(r.boolOptions, t);
                            },
                            get int () {
                                return r.intOptions;
                            },
                            set int (t){
                                Object.assign(r.intOptions, t);
                            },
                            get null () {
                                return r.nullOptions;
                            },
                            set null (t){
                                Object.assign(r.nullOptions, t);
                            },
                            get str () {
                                return r.strOptions;
                            },
                            set str (t){
                                Object.assign(r.strOptions, t);
                            }
                        }, y = {
                            "1.0": {
                                schema: "yaml-1.1",
                                merge: true,
                                tagPrefixes: [
                                    {
                                        handle: "!",
                                        prefix: e.defaultTagPrefix
                                    },
                                    {
                                        handle: "!!",
                                        prefix: "tag:private.yaml.org,2002:"
                                    }
                                ]
                            },
                            1.1: {
                                schema: "yaml-1.1",
                                merge: true,
                                tagPrefixes: [
                                    {
                                        handle: "!",
                                        prefix: "!"
                                    },
                                    {
                                        handle: "!!",
                                        prefix: e.defaultTagPrefix
                                    }
                                ]
                            },
                            1.2: {
                                schema: "core",
                                merge: false,
                                tagPrefixes: [
                                    {
                                        handle: "!",
                                        prefix: "!"
                                    },
                                    {
                                        handle: "!!",
                                        prefix: e.defaultTagPrefix
                                    }
                                ]
                            }
                        };
                        function E(t1, s) {
                            if ((t1.version || t1.options.version) === "1.0") {
                                let g = s.match(/^tag:private\.yaml\.org,2002:([^:/]+)$/);
                                if (g) return "!" + g[1];
                                let u = s.match(/^tag:([a-zA-Z0-9-]+)\.yaml\.org,2002:(.*)/);
                                return u ? `!${u[1]}/${u[2]}` : `!${s.replace(/^tag:/, "")}`;
                            }
                            let a2 = t1.tagPrefixes.find((g)=>s.indexOf(g.prefix) === 0);
                            if (!a2) {
                                let g = t1.getDefaults().tagPrefixes;
                                a2 = g && g.find((u)=>s.indexOf(u.prefix) === 0);
                            }
                            if (!a2) return s[0] === "!" ? s : `!<${s}>`;
                            let m = s.substr(a2.prefix.length).replace(/[!,[\]{}]/g, (g)=>({
                                    "!": "%21",
                                    ",": "%2C",
                                    "[": "%5B",
                                    "]": "%5D",
                                    "{": "%7B",
                                    "}": "%7D"
                                })[g]);
                            return a2.handle + m;
                        }
                        function I(t1, s) {
                            if (s instanceof r.Alias) return r.Alias;
                            if (s.tag) {
                                let g = t1.filter((u)=>u.tag === s.tag);
                                if (g.length > 0) return g.find((u)=>u.format === s.format) || g[0];
                            }
                            let a2, m;
                            if (s instanceof r.Scalar) {
                                m = s.value;
                                let g = t1.filter((u)=>u.identify && u.identify(m) || u.class && m instanceof u.class);
                                a2 = g.find((u)=>u.format === s.format) || g.find((u)=>!u.format);
                            } else m = s, a2 = t1.find((g)=>g.nodeClass && m instanceof g.nodeClass);
                            if (!a2) {
                                let g = m && m.constructor ? m.constructor.name : typeof m;
                                throw new Error(`Tag not resolved for ${g} value`);
                            }
                            return a2;
                        }
                        function S(t1, s, a2) {
                            let { anchors: m, doc: g } = a2, u = [], p = g.anchors.getName(t1);
                            return p && (m[p] = t1, u.push(`&${p}`)), t1.tag ? u.push(E(g, t1.tag)) : s.default || u.push(E(g, s.tag)), u.join(" ");
                        }
                        function M(t1, s, a2, m) {
                            let { anchors: g, schema: u } = s.doc, p;
                            if (!(t1 instanceof r.Node)) {
                                let $ = {
                                    aliasNodes: [],
                                    onTagObj: (K)=>p = K,
                                    prevObjects: /* @__PURE__ */ new Map()
                                };
                                t1 = u.createNode(t1, true, null, $);
                                for (let K of $.aliasNodes){
                                    K.source = K.source.node;
                                    let V = g.getName(K.source);
                                    V || (V = g.newName(), g.map[V] = K.source);
                                }
                            }
                            if (t1 instanceof r.Pair) return t1.toString(s, a2, m);
                            p || (p = I(u.tags, t1));
                            let L = S(t1, p, s);
                            L.length > 0 && (s.indentAtStart = (s.indentAtStart || 0) + L.length + 1);
                            let k = typeof p.stringify == "function" ? p.stringify(t1, s, a2, m) : t1 instanceof r.Scalar ? r.stringifyString(t1, s, a2, m) : t1.toString(s, a2, m);
                            return L ? t1 instanceof r.Scalar || k[0] === "{" || k[0] === "[" ? `${L} ${k}` : `${L}
${s.indent}${k}` : k;
                        }
                        var T = class {
                            static validAnchorNode(t1) {
                                return t1 instanceof r.Scalar || t1 instanceof r.YAMLSeq || t1 instanceof r.YAMLMap;
                            }
                            createAlias(t1, s) {
                                return this.setAnchor(t1, s), new r.Alias(t1);
                            }
                            createMergePair() {
                                let t1 = new r.Merge();
                                for(var s = arguments.length, a2 = new Array(s), m = 0; m < s; m++)a2[m] = arguments[m];
                                return t1.value.items = a2.map((g)=>{
                                    if (g instanceof r.Alias) {
                                        if (g.source instanceof r.YAMLMap) return g;
                                    } else if (g instanceof r.YAMLMap) return this.createAlias(g);
                                    throw new Error("Merge sources must be Map nodes or their Aliases");
                                }), t1;
                            }
                            getName(t1) {
                                let { map: s } = this;
                                return Object.keys(s).find((a2)=>s[a2] === t1);
                            }
                            getNames() {
                                return Object.keys(this.map);
                            }
                            getNode(t1) {
                                return this.map[t1];
                            }
                            newName(t1) {
                                t1 || (t1 = this.prefix);
                                let s = Object.keys(this.map);
                                for(let a2 = 1;; ++a2){
                                    let m = `${t1}${a2}`;
                                    if (!s.includes(m)) return m;
                                }
                            }
                            resolveNodes() {
                                let { map: t1, _cstAliases: s } = this;
                                Object.keys(t1).forEach((a2)=>{
                                    t1[a2] = t1[a2].resolved;
                                }), s.forEach((a2)=>{
                                    a2.source = a2.source.resolved;
                                }), delete this._cstAliases;
                            }
                            setAnchor(t1, s) {
                                if (t1 != null && !T.validAnchorNode(t1)) throw new Error("Anchors may only be set for Scalar, Seq and Map nodes");
                                if (s && /[\x00-\x19\s,[\]{}]/.test(s)) throw new Error("Anchor names must not contain whitespace or control characters");
                                let { map: a2 } = this, m = t1 && Object.keys(a2).find((g)=>a2[g] === t1);
                                if (m) if (s) m !== s && (delete a2[m], a2[s] = t1);
                                else return m;
                                else {
                                    if (!s) {
                                        if (!t1) return null;
                                        s = this.newName();
                                    }
                                    a2[s] = t1;
                                }
                                return s;
                            }
                            constructor(t1){
                                e._defineProperty(this, "map", /* @__PURE__ */ Object.create(null)), this.prefix = t1;
                            }
                        }, P = (t1, s)=>{
                            if (t1 && typeof t1 == "object") {
                                let { tag: a2 } = t1;
                                t1 instanceof r.Collection ? (a2 && (s[a2] = true), t1.items.forEach((m)=>P(m, s))) : t1 instanceof r.Pair ? (P(t1.key, s), P(t1.value, s)) : t1 instanceof r.Scalar && a2 && (s[a2] = true);
                            }
                            return s;
                        }, C = (t1)=>Object.keys(P(t1, {}));
                        function q(t1, s) {
                            let a2 = {
                                before: [],
                                after: []
                            }, m, g = false;
                            for (let u of s)if (u.valueRange) {
                                if (m !== void 0) {
                                    let L = "Document contains trailing content not separated by a ... or --- line";
                                    t1.errors.push(new e.YAMLSyntaxError(u, L));
                                    break;
                                }
                                let p = r.resolveNode(t1, u);
                                g && (p.spaceBefore = true, g = false), m = p;
                            } else u.comment !== null ? (m === void 0 ? a2.before : a2.after).push(u.comment) : u.type === e.Type.BLANK_LINE && (g = true, m === void 0 && a2.before.length > 0 && !t1.commentBefore && (t1.commentBefore = a2.before.join(`
`), a2.before = []));
                            if (t1.contents = m || null, !m) t1.comment = a2.before.concat(a2.after).join(`
`) || null;
                            else {
                                let u = a2.before.join(`
`);
                                if (u) {
                                    let p = m instanceof r.Collection && m.items[0] ? m.items[0] : m;
                                    p.commentBefore = p.commentBefore ? `${u}
${p.commentBefore}` : u;
                                }
                                t1.comment = a2.after.join(`
`) || null;
                            }
                        }
                        function R(t1, s) {
                            let { tagPrefixes: a2 } = t1, [m, g] = s.parameters;
                            if (!m || !g) {
                                let u = "Insufficient parameters given for %TAG directive";
                                throw new e.YAMLSemanticError(s, u);
                            }
                            if (a2.some((u)=>u.handle === m)) {
                                let u = "The %TAG directive must only be given at most once per handle in the same document.";
                                throw new e.YAMLSemanticError(s, u);
                            }
                            return {
                                handle: m,
                                prefix: g
                            };
                        }
                        function B(t1, s) {
                            let [a2] = s.parameters;
                            if (s.name === "YAML:1.0" && (a2 = "1.0"), !a2) {
                                let m = "Insufficient parameters given for %YAML directive";
                                throw new e.YAMLSemanticError(s, m);
                            }
                            if (!y[a2]) {
                                let g = `Document will be parsed as YAML ${t1.version || t1.options.version} rather than YAML ${a2}`;
                                t1.warnings.push(new e.YAMLWarning(s, g));
                            }
                            return a2;
                        }
                        function U(t1, s, a2) {
                            let m = [], g = false;
                            for (let u of s){
                                let { comment: p, name: L } = u;
                                switch(L){
                                    case "TAG":
                                        try {
                                            t1.tagPrefixes.push(R(t1, u));
                                        } catch (k) {
                                            t1.errors.push(k);
                                        }
                                        g = true;
                                        break;
                                    case "YAML":
                                    case "YAML:1.0":
                                        if (t1.version) {
                                            let k = "The %YAML directive must only be given at most once per document.";
                                            t1.errors.push(new e.YAMLSemanticError(u, k));
                                        }
                                        try {
                                            t1.version = B(t1, u);
                                        } catch (k) {
                                            t1.errors.push(k);
                                        }
                                        g = true;
                                        break;
                                    default:
                                        if (L) {
                                            let k = `YAML only supports %TAG and %YAML directives, and not %${L}`;
                                            t1.warnings.push(new e.YAMLWarning(u, k));
                                        }
                                }
                                p && m.push(p);
                            }
                            if (a2 && !g && (t1.version || a2.version || t1.options.version) === "1.1") {
                                let u = (p)=>{
                                    let { handle: L, prefix: k } = p;
                                    return {
                                        handle: L,
                                        prefix: k
                                    };
                                };
                                t1.tagPrefixes = a2.tagPrefixes.map(u), t1.version = a2.version;
                            }
                            t1.commentBefore = m.join(`
`) || null;
                        }
                        function f2(t1) {
                            if (t1 instanceof r.Collection) return true;
                            throw new Error("Expected a YAML collection as document contents");
                        }
                        var i = class {
                            add(t1) {
                                return f2(this.contents), this.contents.add(t1);
                            }
                            addIn(t1, s) {
                                f2(this.contents), this.contents.addIn(t1, s);
                            }
                            delete(t1) {
                                return f2(this.contents), this.contents.delete(t1);
                            }
                            deleteIn(t1) {
                                return r.isEmptyPath(t1) ? this.contents == null ? false : (this.contents = null, true) : (f2(this.contents), this.contents.deleteIn(t1));
                            }
                            getDefaults() {
                                return i.defaults[this.version] || i.defaults[this.options.version] || {};
                            }
                            get(t1, s) {
                                return this.contents instanceof r.Collection ? this.contents.get(t1, s) : void 0;
                            }
                            getIn(t1, s) {
                                return r.isEmptyPath(t1) ? !s && this.contents instanceof r.Scalar ? this.contents.value : this.contents : this.contents instanceof r.Collection ? this.contents.getIn(t1, s) : void 0;
                            }
                            has(t1) {
                                return this.contents instanceof r.Collection ? this.contents.has(t1) : false;
                            }
                            hasIn(t1) {
                                return r.isEmptyPath(t1) ? this.contents !== void 0 : this.contents instanceof r.Collection ? this.contents.hasIn(t1) : false;
                            }
                            set(t1, s) {
                                f2(this.contents), this.contents.set(t1, s);
                            }
                            setIn(t1, s) {
                                r.isEmptyPath(t1) ? this.contents = s : (f2(this.contents), this.contents.setIn(t1, s));
                            }
                            setSchema(t1, s) {
                                if (!t1 && !s && this.schema) return;
                                typeof t1 == "number" && (t1 = t1.toFixed(1)), t1 === "1.0" || t1 === "1.1" || t1 === "1.2" ? (this.version ? this.version = t1 : this.options.version = t1, delete this.options.schema) : t1 && typeof t1 == "string" && (this.options.schema = t1), Array.isArray(s) && (this.options.customTags = s);
                                let a2 = Object.assign({}, this.getDefaults(), this.options);
                                this.schema = new c.Schema(a2);
                            }
                            parse(t1, s) {
                                this.options.keepCstNodes && (this.cstNode = t1), this.options.keepNodeTypes && (this.type = "DOCUMENT");
                                let { directives: a2 = [], contents: m = [], directivesEndMarker: g, error: u, valueRange: p } = t1;
                                if (u && (u.source || (u.source = this), this.errors.push(u)), U(this, a2, s), g && (this.directivesEndMarker = true), this.range = p ? [
                                    p.start,
                                    p.end
                                ] : null, this.setSchema(), this.anchors._cstAliases = [], q(this, m), this.anchors.resolveNodes(), this.options.prettyErrors) {
                                    for (let L of this.errors)L instanceof e.YAMLError && L.makePretty();
                                    for (let L of this.warnings)L instanceof e.YAMLError && L.makePretty();
                                }
                                return this;
                            }
                            listNonDefaultTags() {
                                return C(this.contents).filter((t1)=>t1.indexOf(c.Schema.defaultPrefix) !== 0);
                            }
                            setTagPrefix(t1, s) {
                                if (t1[0] !== "!" || t1[t1.length - 1] !== "!") throw new Error("Handle must start and end with !");
                                if (s) {
                                    let a2 = this.tagPrefixes.find((m)=>m.handle === t1);
                                    a2 ? a2.prefix = s : this.tagPrefixes.push({
                                        handle: t1,
                                        prefix: s
                                    });
                                } else this.tagPrefixes = this.tagPrefixes.filter((a2)=>a2.handle !== t1);
                            }
                            toJSON(t1, s) {
                                let { keepBlobsInJSON: a2, mapAsMap: m, maxAliasCount: g } = this.options, u = a2 && (typeof t1 != "string" || !(this.contents instanceof r.Scalar)), p = {
                                    doc: this,
                                    indentStep: "  ",
                                    keep: u,
                                    mapAsMap: u && !!m,
                                    maxAliasCount: g,
                                    stringify: M
                                }, L = Object.keys(this.anchors.map);
                                L.length > 0 && (p.anchors = new Map(L.map(($)=>[
                                        this.anchors.map[$],
                                        {
                                            alias: [],
                                            aliasCount: 0,
                                            count: 1
                                        }
                                    ])));
                                let k = r.toJSON(this.contents, t1, p);
                                if (typeof s == "function" && p.anchors) for (let { count: $, res: K } of p.anchors.values())s(K, $);
                                return k;
                            }
                            toString() {
                                if (this.errors.length > 0) throw new Error("Document with errors cannot be stringified");
                                let t1 = this.options.indent;
                                if (!Number.isInteger(t1) || t1 <= 0) {
                                    let L = JSON.stringify(t1);
                                    throw new Error(`"indent" option must be a positive integer, not ${L}`);
                                }
                                this.setSchema();
                                let s = [], a2 = false;
                                if (this.version) {
                                    let L = "%YAML 1.2";
                                    this.schema.name === "yaml-1.1" && (this.version === "1.0" ? L = "%YAML:1.0" : this.version === "1.1" && (L = "%YAML 1.1")), s.push(L), a2 = true;
                                }
                                let m = this.listNonDefaultTags();
                                this.tagPrefixes.forEach((L)=>{
                                    let { handle: k, prefix: $ } = L;
                                    m.some((K)=>K.indexOf($) === 0) && (s.push(`%TAG ${k} ${$}`), a2 = true);
                                }), (a2 || this.directivesEndMarker) && s.push("---"), this.commentBefore && ((a2 || !this.directivesEndMarker) && s.unshift(""), s.unshift(this.commentBefore.replace(/^/gm, "#")));
                                let g = {
                                    anchors: /* @__PURE__ */ Object.create(null),
                                    doc: this,
                                    indent: "",
                                    indentStep: " ".repeat(t1),
                                    stringify: M
                                }, u = false, p = null;
                                if (this.contents) {
                                    this.contents instanceof r.Node && (this.contents.spaceBefore && (a2 || this.directivesEndMarker) && s.push(""), this.contents.commentBefore && s.push(this.contents.commentBefore.replace(/^/gm, "#")), g.forceBlockIndent = !!this.comment, p = this.contents.comment);
                                    let L = p ? null : ()=>u = true, k = M(this.contents, g, ()=>p = null, L);
                                    s.push(r.addComment(k, "", p));
                                } else this.contents !== void 0 && s.push(M(this.contents, g));
                                return this.comment && ((!u || p) && s[s.length - 1] !== "" && s.push(""), s.push(this.comment.replace(/^/gm, "#"))), s.join(`
`) + `
`;
                            }
                            constructor(t1){
                                this.anchors = new T(t1.anchorPrefix), this.commentBefore = null, this.comment = null, this.contents = null, this.directivesEndMarker = null, this.errors = [], this.options = t1, this.schema = null, this.tagPrefixes = [], this.version = null, this.warnings = [];
                            }
                        };
                        e._defineProperty(i, "defaults", y), n.Document = i, n.defaultOptions = h, n.scalarOptions = d;
                    }
                }), Hr = D({
                    "node_modules/yaml/dist/index.js" (n) {
                        "use strict";
                        Y();
                        var e = Jr(), r = xr(), c = it(), h = Me(), d = st();
                        ke();
                        function y(C) {
                            let q = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true, R = arguments.length > 2 ? arguments[2] : void 0;
                            R === void 0 && typeof q == "string" && (R = q, q = true);
                            let B = Object.assign({}, r.Document.defaults[r.defaultOptions.version], r.defaultOptions);
                            return new c.Schema(B).createNode(C, q, R);
                        }
                        var E = class extends r.Document {
                            constructor(C){
                                super(Object.assign({}, r.defaultOptions, C));
                            }
                        };
                        function I(C, q) {
                            let R = [], B;
                            for (let U of e.parse(C)){
                                let f2 = new E(q);
                                f2.parse(U, B), R.push(f2), B = f2;
                            }
                            return R;
                        }
                        function S(C, q) {
                            let R = e.parse(C), B = new E(q).parse(R[0]);
                            if (R.length > 1) {
                                let U = "Source contains multiple documents; please use YAML.parseAllDocuments()";
                                B.errors.unshift(new h.YAMLSemanticError(R[1], U));
                            }
                            return B;
                        }
                        function M(C, q) {
                            let R = S(C, q);
                            if (R.warnings.forEach((B)=>d.warn(B)), R.errors.length > 0) throw R.errors[0];
                            return R.toJSON();
                        }
                        function T(C, q) {
                            let R = new E(q);
                            return R.contents = C, String(R);
                        }
                        var P = {
                            createNode: y,
                            defaultOptions: r.defaultOptions,
                            Document: E,
                            parse: M,
                            parseAllDocuments: I,
                            parseCST: e.parse,
                            parseDocument: S,
                            scalarOptions: r.scalarOptions,
                            stringify: T
                        };
                        n.YAML = P;
                    }
                }), Ue = D({
                    "node_modules/yaml/index.js" (n, e) {
                        Y(), e.exports = Hr().YAML;
                    }
                }), Gr = D({
                    "node_modules/yaml/dist/util.js" (n) {
                        "use strict";
                        Y();
                        var e = ke(), r = Me();
                        n.findPair = e.findPair, n.parseMap = e.resolveMap, n.parseSeq = e.resolveSeq, n.stringifyNumber = e.stringifyNumber, n.stringifyString = e.stringifyString, n.toJSON = e.toJSON, n.Type = r.Type, n.YAMLError = r.YAMLError, n.YAMLReferenceError = r.YAMLReferenceError, n.YAMLSemanticError = r.YAMLSemanticError, n.YAMLSyntaxError = r.YAMLSyntaxError, n.YAMLWarning = r.YAMLWarning;
                    }
                }), zr = D({
                    "node_modules/yaml/util.js" (n) {
                        Y();
                        var e = Gr();
                        n.findPair = e.findPair, n.toJSON = e.toJSON, n.parseMap = e.parseMap, n.parseSeq = e.parseSeq, n.stringifyNumber = e.stringifyNumber, n.stringifyString = e.stringifyString, n.Type = e.Type, n.YAMLError = e.YAMLError, n.YAMLReferenceError = e.YAMLReferenceError, n.YAMLSemanticError = e.YAMLSemanticError, n.YAMLSyntaxError = e.YAMLSyntaxError, n.YAMLWarning = e.YAMLWarning;
                    }
                }), Zr = D({
                    "node_modules/yaml-unist-parser/lib/yaml.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Ue();
                        n.Document = e.Document;
                        var r = Ue();
                        n.parseCST = r.parseCST;
                        var c = zr();
                        n.YAMLError = c.YAMLError, n.YAMLSyntaxError = c.YAMLSyntaxError, n.YAMLSemanticError = c.YAMLSemanticError;
                    }
                }), Xr = D({
                    "node_modules/yaml-unist-parser/lib/parse.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = Kt(), r = xt(), c = Ht(), h = Gt(), d = Br(), y = He(), E = Yr(), I = Fr(), S = Wr(), M = Vr(), T = Qr(), P = Kr(), C = Zr();
                        function q(R) {
                            var B = C.parseCST(R);
                            M.addOrigRange(B);
                            for(var U = B.map(function(k) {
                                return new C.Document({
                                    merge: false,
                                    keepCstNodes: true
                                }).parse(k);
                            }), f2 = new e.default(R), i = [], t1 = {
                                text: R,
                                locator: f2,
                                comments: i,
                                transformOffset: function(k) {
                                    return I.transformOffset(k, t1);
                                },
                                transformRange: function(k) {
                                    return S.transformRange(k, t1);
                                },
                                transformNode: function(k) {
                                    return d.transformNode(k, t1);
                                },
                                transformContent: function(k) {
                                    return y.transformContent(k, t1);
                                }
                            }, s = 0, a2 = U; s < a2.length; s++)for(var m = a2[s], g = 0, u = m.errors; g < u.length; g++){
                                var p = u[g];
                                if (!(p instanceof C.YAMLSemanticError && p.message === 'Map keys must be unique; "<<" is repeated')) throw E.transformError(p, t1);
                            }
                            U.forEach(function(k) {
                                return h.removeCstBlankLine(k.cstNode);
                            });
                            var L = c.createRoot(t1.transformRange({
                                origStart: 0,
                                origEnd: t1.text.length
                            }), U.map(t1.transformNode), i);
                            return r.attachComments(L), P.updatePositions(L), T.removeFakeNodes(L), L;
                        }
                        n.parse = q;
                    }
                }), en = D({
                    "node_modules/yaml-unist-parser/lib/index.js" (n) {
                        "use strict";
                        Y(), n.__esModule = true;
                        var e = (ie(), se(te));
                        e.__exportStar(Xr(), n);
                    }
                });
                Y();
                var tn = Mt(), { hasPragma: rn } = Ot(), { locStart: nn, locEnd: sn } = Lt();
                function an(n) {
                    let { parse: e } = en();
                    try {
                        let r = e(n);
                        return delete r.comments, r;
                    } catch (r) {
                        throw r != null && r.position ? tn(r.message, r.position) : r;
                    }
                }
                var on = {
                    astFormat: "yaml",
                    parse: an,
                    hasPragma: rn,
                    locStart: nn,
                    locEnd: sn
                };
                at.exports = {
                    parsers: {
                        yaml: on
                    }
                };
            });
            return ln();
        });
    }
});
// ../../node_modules/lodash/lodash.js
var require_lodash = __commonJS({
    "../../node_modules/lodash/lodash.js" (exports, module) {
        (function() {
            var undefined2;
            var VERSION = "4.17.21";
            var LARGE_ARRAY_SIZE = 200;
            var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
            var HASH_UNDEFINED = "__lodash_hash_undefined__";
            var MAX_MEMOIZE_SIZE = 500;
            var PLACEHOLDER = "__lodash_placeholder__";
            var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4;
            var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
            var WRAP_BIND_FLAG = 1, WRAP_BIND_KEY_FLAG = 2, WRAP_CURRY_BOUND_FLAG = 4, WRAP_CURRY_FLAG = 8, WRAP_CURRY_RIGHT_FLAG = 16, WRAP_PARTIAL_FLAG = 32, WRAP_PARTIAL_RIGHT_FLAG = 64, WRAP_ARY_FLAG = 128, WRAP_REARG_FLAG = 256, WRAP_FLIP_FLAG = 512;
            var DEFAULT_TRUNC_LENGTH = 30, DEFAULT_TRUNC_OMISSION = "...";
            var HOT_COUNT = 800, HOT_SPAN = 16;
            var LAZY_FILTER_FLAG = 1, LAZY_MAP_FLAG = 2, LAZY_WHILE_FLAG = 3;
            var INFINITY = 1 / 0, MAX_SAFE_INTEGER = 9007199254740991, MAX_INTEGER = 17976931348623157e292, NAN = 0 / 0;
            var MAX_ARRAY_LENGTH = 4294967295, MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
            var wrapFlags = [
                [
                    "ary",
                    WRAP_ARY_FLAG
                ],
                [
                    "bind",
                    WRAP_BIND_FLAG
                ],
                [
                    "bindKey",
                    WRAP_BIND_KEY_FLAG
                ],
                [
                    "curry",
                    WRAP_CURRY_FLAG
                ],
                [
                    "curryRight",
                    WRAP_CURRY_RIGHT_FLAG
                ],
                [
                    "flip",
                    WRAP_FLIP_FLAG
                ],
                [
                    "partial",
                    WRAP_PARTIAL_FLAG
                ],
                [
                    "partialRight",
                    WRAP_PARTIAL_RIGHT_FLAG
                ],
                [
                    "rearg",
                    WRAP_REARG_FLAG
                ]
            ];
            var argsTag = "[object Arguments]", arrayTag = "[object Array]", asyncTag = "[object AsyncFunction]", boolTag2 = "[object Boolean]", dateTag = "[object Date]", domExcTag = "[object DOMException]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", nullTag2 = "[object Null]", objectTag = "[object Object]", promiseTag = "[object Promise]", proxyTag = "[object Proxy]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", undefinedTag = "[object Undefined]", weakMapTag = "[object WeakMap]", weakSetTag = "[object WeakSet]";
            var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
            var reEmptyStringLeading = /\b__p \+= '';/g, reEmptyStringMiddle = /\b(__p \+=) '' \+/g, reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
            var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, reUnescapedHtml = /[&<>"']/g, reHasEscapedHtml = RegExp(reEscapedHtml.source), reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
            var reEscape = /<%-([\s\S]+?)%>/g, reEvaluate = /<%([\s\S]+?)%>/g, reInterpolate = /<%=([\s\S]+?)%>/g;
            var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
            var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, reHasRegExpChar = RegExp(reRegExpChar.source);
            var reTrimStart = /^\s+/;
            var reWhitespace = /\s/;
            var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, reSplitDetails = /,? & /;
            var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
            var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
            var reEscapeChar = /\\(\\)?/g;
            var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
            var reFlags = /\w*$/;
            var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
            var reIsBinary = /^0b[01]+$/i;
            var reIsHostCtor = /^\[object .+?Constructor\]$/;
            var reIsOctal = /^0o[0-7]+$/i;
            var reIsUint = /^(?:0|[1-9]\d*)$/;
            var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
            var reNoMatch = /($^)/;
            var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
            var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
            var rsApos = "['\u2019]", rsAstral = "[" + rsAstralRange + "]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d";
            var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")", rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [
                rsNonAstral,
                rsRegional,
                rsSurrPair
            ].join("|") + ")" + rsOptVar + reOptMod + ")*", rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [
                rsDingbat,
                rsRegional,
                rsSurrPair
            ].join("|") + ")" + rsSeq, rsSymbol = "(?:" + [
                rsNonAstral + rsCombo + "?",
                rsCombo,
                rsRegional,
                rsSurrPair,
                rsAstral
            ].join("|") + ")";
            var reApos = RegExp(rsApos, "g");
            var reComboMark = RegExp(rsCombo, "g");
            var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
            var reUnicodeWord = RegExp([
                rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [
                    rsBreak,
                    rsUpper,
                    "$"
                ].join("|") + ")",
                rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [
                    rsBreak,
                    rsUpper + rsMiscLower,
                    "$"
                ].join("|") + ")",
                rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
                rsUpper + "+" + rsOptContrUpper,
                rsOrdUpper,
                rsOrdLower,
                rsDigits,
                rsEmoji
            ].join("|"), "g");
            var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
            var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
            var contextProps = [
                "Array",
                "Buffer",
                "DataView",
                "Date",
                "Error",
                "Float32Array",
                "Float64Array",
                "Function",
                "Int8Array",
                "Int16Array",
                "Int32Array",
                "Map",
                "Math",
                "Object",
                "Promise",
                "RegExp",
                "Set",
                "String",
                "Symbol",
                "TypeError",
                "Uint8Array",
                "Uint8ClampedArray",
                "Uint16Array",
                "Uint32Array",
                "WeakMap",
                "_",
                "clearTimeout",
                "isFinite",
                "parseInt",
                "setTimeout"
            ];
            var templateCounter = -1;
            var typedArrayTags = {};
            typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
            typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag2] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
            var cloneableTags = {};
            cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag2] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
            cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
            var deburredLetters = {
                // Latin-1 Supplement block.
                "\xC0": "A",
                "\xC1": "A",
                "\xC2": "A",
                "\xC3": "A",
                "\xC4": "A",
                "\xC5": "A",
                "\xE0": "a",
                "\xE1": "a",
                "\xE2": "a",
                "\xE3": "a",
                "\xE4": "a",
                "\xE5": "a",
                "\xC7": "C",
                "\xE7": "c",
                "\xD0": "D",
                "\xF0": "d",
                "\xC8": "E",
                "\xC9": "E",
                "\xCA": "E",
                "\xCB": "E",
                "\xE8": "e",
                "\xE9": "e",
                "\xEA": "e",
                "\xEB": "e",
                "\xCC": "I",
                "\xCD": "I",
                "\xCE": "I",
                "\xCF": "I",
                "\xEC": "i",
                "\xED": "i",
                "\xEE": "i",
                "\xEF": "i",
                "\xD1": "N",
                "\xF1": "n",
                "\xD2": "O",
                "\xD3": "O",
                "\xD4": "O",
                "\xD5": "O",
                "\xD6": "O",
                "\xD8": "O",
                "\xF2": "o",
                "\xF3": "o",
                "\xF4": "o",
                "\xF5": "o",
                "\xF6": "o",
                "\xF8": "o",
                "\xD9": "U",
                "\xDA": "U",
                "\xDB": "U",
                "\xDC": "U",
                "\xF9": "u",
                "\xFA": "u",
                "\xFB": "u",
                "\xFC": "u",
                "\xDD": "Y",
                "\xFD": "y",
                "\xFF": "y",
                "\xC6": "Ae",
                "\xE6": "ae",
                "\xDE": "Th",
                "\xFE": "th",
                "\xDF": "ss",
                // Latin Extended-A block.
                "\u0100": "A",
                "\u0102": "A",
                "\u0104": "A",
                "\u0101": "a",
                "\u0103": "a",
                "\u0105": "a",
                "\u0106": "C",
                "\u0108": "C",
                "\u010A": "C",
                "\u010C": "C",
                "\u0107": "c",
                "\u0109": "c",
                "\u010B": "c",
                "\u010D": "c",
                "\u010E": "D",
                "\u0110": "D",
                "\u010F": "d",
                "\u0111": "d",
                "\u0112": "E",
                "\u0114": "E",
                "\u0116": "E",
                "\u0118": "E",
                "\u011A": "E",
                "\u0113": "e",
                "\u0115": "e",
                "\u0117": "e",
                "\u0119": "e",
                "\u011B": "e",
                "\u011C": "G",
                "\u011E": "G",
                "\u0120": "G",
                "\u0122": "G",
                "\u011D": "g",
                "\u011F": "g",
                "\u0121": "g",
                "\u0123": "g",
                "\u0124": "H",
                "\u0126": "H",
                "\u0125": "h",
                "\u0127": "h",
                "\u0128": "I",
                "\u012A": "I",
                "\u012C": "I",
                "\u012E": "I",
                "\u0130": "I",
                "\u0129": "i",
                "\u012B": "i",
                "\u012D": "i",
                "\u012F": "i",
                "\u0131": "i",
                "\u0134": "J",
                "\u0135": "j",
                "\u0136": "K",
                "\u0137": "k",
                "\u0138": "k",
                "\u0139": "L",
                "\u013B": "L",
                "\u013D": "L",
                "\u013F": "L",
                "\u0141": "L",
                "\u013A": "l",
                "\u013C": "l",
                "\u013E": "l",
                "\u0140": "l",
                "\u0142": "l",
                "\u0143": "N",
                "\u0145": "N",
                "\u0147": "N",
                "\u014A": "N",
                "\u0144": "n",
                "\u0146": "n",
                "\u0148": "n",
                "\u014B": "n",
                "\u014C": "O",
                "\u014E": "O",
                "\u0150": "O",
                "\u014D": "o",
                "\u014F": "o",
                "\u0151": "o",
                "\u0154": "R",
                "\u0156": "R",
                "\u0158": "R",
                "\u0155": "r",
                "\u0157": "r",
                "\u0159": "r",
                "\u015A": "S",
                "\u015C": "S",
                "\u015E": "S",
                "\u0160": "S",
                "\u015B": "s",
                "\u015D": "s",
                "\u015F": "s",
                "\u0161": "s",
                "\u0162": "T",
                "\u0164": "T",
                "\u0166": "T",
                "\u0163": "t",
                "\u0165": "t",
                "\u0167": "t",
                "\u0168": "U",
                "\u016A": "U",
                "\u016C": "U",
                "\u016E": "U",
                "\u0170": "U",
                "\u0172": "U",
                "\u0169": "u",
                "\u016B": "u",
                "\u016D": "u",
                "\u016F": "u",
                "\u0171": "u",
                "\u0173": "u",
                "\u0174": "W",
                "\u0175": "w",
                "\u0176": "Y",
                "\u0177": "y",
                "\u0178": "Y",
                "\u0179": "Z",
                "\u017B": "Z",
                "\u017D": "Z",
                "\u017A": "z",
                "\u017C": "z",
                "\u017E": "z",
                "\u0132": "IJ",
                "\u0133": "ij",
                "\u0152": "Oe",
                "\u0153": "oe",
                "\u0149": "'n",
                "\u017F": "s"
            };
            var htmlEscapes = {
                "&": "&amp;",
                "<": "&lt;",
                ">": "&gt;",
                '"': "&quot;",
                "'": "&#39;"
            };
            var htmlUnescapes = {
                "&amp;": "&",
                "&lt;": "<",
                "&gt;": ">",
                "&quot;": '"',
                "&#39;": "'"
            };
            var stringEscapes = {
                "\\": "\\",
                "'": "'",
                "\n": "n",
                "\r": "r",
                "\u2028": "u2028",
                "\u2029": "u2029"
            };
            var freeParseFloat = parseFloat, freeParseInt = parseInt;
            var freeGlobal = typeof __webpack_require__.g == "object" && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g;
            var freeSelf = typeof self == "object" && self && self.Object === Object && self;
            var root = freeGlobal || freeSelf || Function("return this")();
            var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
            var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
            var moduleExports = freeModule && freeModule.exports === freeExports;
            var freeProcess = moduleExports && freeGlobal.process;
            var nodeUtil = function() {
                try {
                    var types = freeModule && freeModule.require && freeModule.require("util").types;
                    if (types) {
                        return types;
                    }
                    return freeProcess && freeProcess.binding && freeProcess.binding("util");
                } catch (e) {}
            }();
            var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, nodeIsDate = nodeUtil && nodeUtil.isDate, nodeIsMap = nodeUtil && nodeUtil.isMap, nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, nodeIsSet = nodeUtil && nodeUtil.isSet, nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
            function apply(func, thisArg, args) {
                switch(args.length){
                    case 0:
                        return func.call(thisArg);
                    case 1:
                        return func.call(thisArg, args[0]);
                    case 2:
                        return func.call(thisArg, args[0], args[1]);
                    case 3:
                        return func.call(thisArg, args[0], args[1], args[2]);
                }
                return func.apply(thisArg, args);
            }
            function arrayAggregator(array, setter, iteratee, accumulator) {
                var index = -1, length = array == null ? 0 : array.length;
                while(++index < length){
                    var value1 = array[index];
                    setter(accumulator, value1, iteratee(value1), array);
                }
                return accumulator;
            }
            function arrayEach(array, iteratee) {
                var index = -1, length = array == null ? 0 : array.length;
                while(++index < length){
                    if (iteratee(array[index], index, array) === false) {
                        break;
                    }
                }
                return array;
            }
            function arrayEachRight(array, iteratee) {
                var length = array == null ? 0 : array.length;
                while(length--){
                    if (iteratee(array[length], length, array) === false) {
                        break;
                    }
                }
                return array;
            }
            function arrayEvery(array, predicate) {
                var index = -1, length = array == null ? 0 : array.length;
                while(++index < length){
                    if (!predicate(array[index], index, array)) {
                        return false;
                    }
                }
                return true;
            }
            function arrayFilter(array, predicate) {
                var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
                while(++index < length){
                    var value1 = array[index];
                    if (predicate(value1, index, array)) {
                        result[resIndex++] = value1;
                    }
                }
                return result;
            }
            function arrayIncludes(array, value1) {
                var length = array == null ? 0 : array.length;
                return !!length && baseIndexOf(array, value1, 0) > -1;
            }
            function arrayIncludesWith(array, value1, comparator) {
                var index = -1, length = array == null ? 0 : array.length;
                while(++index < length){
                    if (comparator(value1, array[index])) {
                        return true;
                    }
                }
                return false;
            }
            function arrayMap(array, iteratee) {
                var index = -1, length = array == null ? 0 : array.length, result = Array(length);
                while(++index < length){
                    result[index] = iteratee(array[index], index, array);
                }
                return result;
            }
            function arrayPush(array, values) {
                var index = -1, length = values.length, offset = array.length;
                while(++index < length){
                    array[offset + index] = values[index];
                }
                return array;
            }
            function arrayReduce(array, iteratee, accumulator, initAccum) {
                var index = -1, length = array == null ? 0 : array.length;
                if (initAccum && length) {
                    accumulator = array[++index];
                }
                while(++index < length){
                    accumulator = iteratee(accumulator, array[index], index, array);
                }
                return accumulator;
            }
            function arrayReduceRight(array, iteratee, accumulator, initAccum) {
                var length = array == null ? 0 : array.length;
                if (initAccum && length) {
                    accumulator = array[--length];
                }
                while(length--){
                    accumulator = iteratee(accumulator, array[length], length, array);
                }
                return accumulator;
            }
            function arraySome(array, predicate) {
                var index = -1, length = array == null ? 0 : array.length;
                while(++index < length){
                    if (predicate(array[index], index, array)) {
                        return true;
                    }
                }
                return false;
            }
            var asciiSize = baseProperty("length");
            function asciiToArray(string2) {
                return string2.split("");
            }
            function asciiWords(string2) {
                return string2.match(reAsciiWord) || [];
            }
            function baseFindKey(collection, predicate, eachFunc) {
                var result;
                eachFunc(collection, function(value1, key, collection2) {
                    if (predicate(value1, key, collection2)) {
                        result = key;
                        return false;
                    }
                });
                return result;
            }
            function baseFindIndex(array, predicate, fromIndex, fromRight) {
                var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
                while(fromRight ? index-- : ++index < length){
                    if (predicate(array[index], index, array)) {
                        return index;
                    }
                }
                return -1;
            }
            function baseIndexOf(array, value1, fromIndex) {
                return value1 === value1 ? strictIndexOf(array, value1, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
            }
            function baseIndexOfWith(array, value1, fromIndex, comparator) {
                var index = fromIndex - 1, length = array.length;
                while(++index < length){
                    if (comparator(array[index], value1)) {
                        return index;
                    }
                }
                return -1;
            }
            function baseIsNaN(value1) {
                return value1 !== value1;
            }
            function baseMean(array, iteratee) {
                var length = array == null ? 0 : array.length;
                return length ? baseSum(array, iteratee) / length : NAN;
            }
            function baseProperty(key) {
                return function(object) {
                    return object == null ? undefined2 : object[key];
                };
            }
            function basePropertyOf(object) {
                return function(key) {
                    return object == null ? undefined2 : object[key];
                };
            }
            function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
                eachFunc(collection, function(value1, index, collection2) {
                    accumulator = initAccum ? (initAccum = false, value1) : iteratee(accumulator, value1, index, collection2);
                });
                return accumulator;
            }
            function baseSortBy(array, comparer) {
                var length = array.length;
                array.sort(comparer);
                while(length--){
                    array[length] = array[length].value;
                }
                return array;
            }
            function baseSum(array, iteratee) {
                var result, index = -1, length = array.length;
                while(++index < length){
                    var current = iteratee(array[index]);
                    if (current !== undefined2) {
                        result = result === undefined2 ? current : result + current;
                    }
                }
                return result;
            }
            function baseTimes(n, iteratee) {
                var index = -1, result = Array(n);
                while(++index < n){
                    result[index] = iteratee(index);
                }
                return result;
            }
            function baseToPairs(object, props) {
                return arrayMap(props, function(key) {
                    return [
                        key,
                        object[key]
                    ];
                });
            }
            function baseTrim(string2) {
                return string2 ? string2.slice(0, trimmedEndIndex(string2) + 1).replace(reTrimStart, "") : string2;
            }
            function baseUnary(func) {
                return function(value1) {
                    return func(value1);
                };
            }
            function baseValues(object, props) {
                return arrayMap(props, function(key) {
                    return object[key];
                });
            }
            function cacheHas(cache, key) {
                return cache.has(key);
            }
            function charsStartIndex(strSymbols, chrSymbols) {
                var index = -1, length = strSymbols.length;
                while(++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1){}
                return index;
            }
            function charsEndIndex(strSymbols, chrSymbols) {
                var index = strSymbols.length;
                while(index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1){}
                return index;
            }
            function countHolders(array, placeholder) {
                var length = array.length, result = 0;
                while(length--){
                    if (array[length] === placeholder) {
                        ++result;
                    }
                }
                return result;
            }
            var deburrLetter = basePropertyOf(deburredLetters);
            var escapeHtmlChar = basePropertyOf(htmlEscapes);
            function escapeStringChar(chr) {
                return "\\" + stringEscapes[chr];
            }
            function getValue(object, key) {
                return object == null ? undefined2 : object[key];
            }
            function hasUnicode(string2) {
                return reHasUnicode.test(string2);
            }
            function hasUnicodeWord(string2) {
                return reHasUnicodeWord.test(string2);
            }
            function iteratorToArray(iterator) {
                var data, result = [];
                while(!(data = iterator.next()).done){
                    result.push(data.value);
                }
                return result;
            }
            function mapToArray(map2) {
                var index = -1, result = Array(map2.size);
                map2.forEach(function(value1, key) {
                    result[++index] = [
                        key,
                        value1
                    ];
                });
                return result;
            }
            function overArg(func, transform) {
                return function(arg) {
                    return func(transform(arg));
                };
            }
            function replaceHolders(array, placeholder) {
                var index = -1, length = array.length, resIndex = 0, result = [];
                while(++index < length){
                    var value1 = array[index];
                    if (value1 === placeholder || value1 === PLACEHOLDER) {
                        array[index] = PLACEHOLDER;
                        result[resIndex++] = index;
                    }
                }
                return result;
            }
            function setToArray(set2) {
                var index = -1, result = Array(set2.size);
                set2.forEach(function(value1) {
                    result[++index] = value1;
                });
                return result;
            }
            function setToPairs(set2) {
                var index = -1, result = Array(set2.size);
                set2.forEach(function(value1) {
                    result[++index] = [
                        value1,
                        value1
                    ];
                });
                return result;
            }
            function strictIndexOf(array, value1, fromIndex) {
                var index = fromIndex - 1, length = array.length;
                while(++index < length){
                    if (array[index] === value1) {
                        return index;
                    }
                }
                return -1;
            }
            function strictLastIndexOf(array, value1, fromIndex) {
                var index = fromIndex + 1;
                while(index--){
                    if (array[index] === value1) {
                        return index;
                    }
                }
                return index;
            }
            function stringSize(string2) {
                return hasUnicode(string2) ? unicodeSize(string2) : asciiSize(string2);
            }
            function stringToArray(string2) {
                return hasUnicode(string2) ? unicodeToArray(string2) : asciiToArray(string2);
            }
            function trimmedEndIndex(string2) {
                var index = string2.length;
                while(index-- && reWhitespace.test(string2.charAt(index))){}
                return index;
            }
            var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
            function unicodeSize(string2) {
                var result = reUnicode.lastIndex = 0;
                while(reUnicode.test(string2)){
                    ++result;
                }
                return result;
            }
            function unicodeToArray(string2) {
                return string2.match(reUnicode) || [];
            }
            function unicodeWords(string2) {
                return string2.match(reUnicodeWord) || [];
            }
            var runInContext = function runInContext2(context) {
                context = context == null ? root : _2.defaults(root.Object(), context, _2.pick(root, contextProps));
                var Array2 = context.Array, Date2 = context.Date, Error2 = context.Error, Function2 = context.Function, Math2 = context.Math, Object2 = context.Object, RegExp2 = context.RegExp, String2 = context.String, TypeError2 = context.TypeError;
                var arrayProto = Array2.prototype, funcProto = Function2.prototype, objectProto = Object2.prototype;
                var coreJsData = context["__core-js_shared__"];
                var funcToString = funcProto.toString;
                var hasOwnProperty = objectProto.hasOwnProperty;
                var idCounter3 = 0;
                var maskSrcKey = function() {
                    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
                    return uid ? "Symbol(src)_1." + uid : "";
                }();
                var nativeObjectToString = objectProto.toString;
                var objectCtorString = funcToString.call(Object2);
                var oldDash = root._;
                var reIsNative = RegExp2("^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
                var Buffer2 = moduleExports ? context.Buffer : undefined2, Symbol2 = context.Symbol, Uint8Array2 = context.Uint8Array, allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : undefined2, getPrototype = overArg(Object2.getPrototypeOf, Object2), objectCreate = Object2.create, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice, spreadableSymbol = Symbol2 ? Symbol2.isConcatSpreadable : undefined2, symIterator = Symbol2 ? Symbol2.iterator : undefined2, symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined2;
                var defineProperty = function() {
                    try {
                        var func = getNative(Object2, "defineProperty");
                        func({}, "", {});
                        return func;
                    } catch (e) {}
                }();
                var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, ctxNow = Date2 && Date2.now !== root.Date.now && Date2.now, ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
                var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : undefined2, nativeIsFinite = context.isFinite, nativeJoin = arrayProto.join, nativeKeys = overArg(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date2.now, nativeParseInt = context.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto.reverse;
                var DataView = getNative(context, "DataView"), Map2 = getNative(context, "Map"), Promise2 = getNative(context, "Promise"), Set2 = getNative(context, "Set"), WeakMap2 = getNative(context, "WeakMap"), nativeCreate = getNative(Object2, "create");
                var metaMap = WeakMap2 && new WeakMap2();
                var realNames = {};
                var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map2), promiseCtorString = toSource(Promise2), setCtorString = toSource(Set2), weakMapCtorString = toSource(WeakMap2);
                var symbolProto = Symbol2 ? Symbol2.prototype : undefined2, symbolValueOf = symbolProto ? symbolProto.valueOf : undefined2, symbolToString = symbolProto ? symbolProto.toString : undefined2;
                function lodash(value1) {
                    if (isObjectLike(value1) && !isArray(value1) && !(value1 instanceof LazyWrapper)) {
                        if (value1 instanceof LodashWrapper) {
                            return value1;
                        }
                        if (hasOwnProperty.call(value1, "__wrapped__")) {
                            return wrapperClone(value1);
                        }
                    }
                    return new LodashWrapper(value1);
                }
                var baseCreate = /* @__PURE__ */ function() {
                    function object() {}
                    return function(proto) {
                        if (!isObject(proto)) {
                            return {};
                        }
                        if (objectCreate) {
                            return objectCreate(proto);
                        }
                        object.prototype = proto;
                        var result2 = new object();
                        object.prototype = undefined2;
                        return result2;
                    };
                }();
                function baseLodash() {}
                function LodashWrapper(value1, chainAll) {
                    this.__wrapped__ = value1;
                    this.__actions__ = [];
                    this.__chain__ = !!chainAll;
                    this.__index__ = 0;
                    this.__values__ = undefined2;
                }
                lodash.templateSettings = {
                    /**
           * Used to detect `data` property values to be HTML-escaped.
           *
           * @memberOf _.templateSettings
           * @type {RegExp}
           */ "escape": reEscape,
                    /**
           * Used to detect code to be evaluated.
           *
           * @memberOf _.templateSettings
           * @type {RegExp}
           */ "evaluate": reEvaluate,
                    /**
           * Used to detect `data` property values to inject.
           *
           * @memberOf _.templateSettings
           * @type {RegExp}
           */ "interpolate": reInterpolate,
                    /**
           * Used to reference the data object in the template text.
           *
           * @memberOf _.templateSettings
           * @type {string}
           */ "variable": "",
                    /**
           * Used to import variables into the compiled template.
           *
           * @memberOf _.templateSettings
           * @type {Object}
           */ "imports": {
                        /**
             * A reference to the `lodash` function.
             *
             * @memberOf _.templateSettings.imports
             * @type {Function}
             */ "_": lodash
                    }
                };
                lodash.prototype = baseLodash.prototype;
                lodash.prototype.constructor = lodash;
                LodashWrapper.prototype = baseCreate(baseLodash.prototype);
                LodashWrapper.prototype.constructor = LodashWrapper;
                function LazyWrapper(value1) {
                    this.__wrapped__ = value1;
                    this.__actions__ = [];
                    this.__dir__ = 1;
                    this.__filtered__ = false;
                    this.__iteratees__ = [];
                    this.__takeCount__ = MAX_ARRAY_LENGTH;
                    this.__views__ = [];
                }
                function lazyClone() {
                    var result2 = new LazyWrapper(this.__wrapped__);
                    result2.__actions__ = copyArray(this.__actions__);
                    result2.__dir__ = this.__dir__;
                    result2.__filtered__ = this.__filtered__;
                    result2.__iteratees__ = copyArray(this.__iteratees__);
                    result2.__takeCount__ = this.__takeCount__;
                    result2.__views__ = copyArray(this.__views__);
                    return result2;
                }
                function lazyReverse() {
                    if (this.__filtered__) {
                        var result2 = new LazyWrapper(this);
                        result2.__dir__ = -1;
                        result2.__filtered__ = true;
                    } else {
                        result2 = this.clone();
                        result2.__dir__ *= -1;
                    }
                    return result2;
                }
                function lazyValue() {
                    var array = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray(array), isRight = dir < 0, arrLength = isArr ? array.length : 0, view = getView(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin(length, this.__takeCount__);
                    if (!isArr || !isRight && arrLength == length && takeCount == length) {
                        return baseWrapperValue(array, this.__actions__);
                    }
                    var result2 = [];
                    outer: while(length-- && resIndex < takeCount){
                        index += dir;
                        var iterIndex = -1, value1 = array[index];
                        while(++iterIndex < iterLength){
                            var data = iteratees[iterIndex], iteratee2 = data.iteratee, type = data.type, computed = iteratee2(value1);
                            if (type == LAZY_MAP_FLAG) {
                                value1 = computed;
                            } else if (!computed) {
                                if (type == LAZY_FILTER_FLAG) {
                                    continue outer;
                                } else {
                                    break outer;
                                }
                            }
                        }
                        result2[resIndex++] = value1;
                    }
                    return result2;
                }
                LazyWrapper.prototype = baseCreate(baseLodash.prototype);
                LazyWrapper.prototype.constructor = LazyWrapper;
                function Hash(entries) {
                    var index = -1, length = entries == null ? 0 : entries.length;
                    this.clear();
                    while(++index < length){
                        var entry = entries[index];
                        this.set(entry[0], entry[1]);
                    }
                }
                function hashClear() {
                    this.__data__ = nativeCreate ? nativeCreate(null) : {};
                    this.size = 0;
                }
                function hashDelete(key) {
                    var result2 = this.has(key) && delete this.__data__[key];
                    this.size -= result2 ? 1 : 0;
                    return result2;
                }
                function hashGet(key) {
                    var data = this.__data__;
                    if (nativeCreate) {
                        var result2 = data[key];
                        return result2 === HASH_UNDEFINED ? undefined2 : result2;
                    }
                    return hasOwnProperty.call(data, key) ? data[key] : undefined2;
                }
                function hashHas(key) {
                    var data = this.__data__;
                    return nativeCreate ? data[key] !== undefined2 : hasOwnProperty.call(data, key);
                }
                function hashSet(key, value1) {
                    var data = this.__data__;
                    this.size += this.has(key) ? 0 : 1;
                    data[key] = nativeCreate && value1 === undefined2 ? HASH_UNDEFINED : value1;
                    return this;
                }
                Hash.prototype.clear = hashClear;
                Hash.prototype["delete"] = hashDelete;
                Hash.prototype.get = hashGet;
                Hash.prototype.has = hashHas;
                Hash.prototype.set = hashSet;
                function ListCache(entries) {
                    var index = -1, length = entries == null ? 0 : entries.length;
                    this.clear();
                    while(++index < length){
                        var entry = entries[index];
                        this.set(entry[0], entry[1]);
                    }
                }
                function listCacheClear() {
                    this.__data__ = [];
                    this.size = 0;
                }
                function listCacheDelete(key) {
                    var data = this.__data__, index = assocIndexOf(data, key);
                    if (index < 0) {
                        return false;
                    }
                    var lastIndex = data.length - 1;
                    if (index == lastIndex) {
                        data.pop();
                    } else {
                        splice.call(data, index, 1);
                    }
                    --this.size;
                    return true;
                }
                function listCacheGet(key) {
                    var data = this.__data__, index = assocIndexOf(data, key);
                    return index < 0 ? undefined2 : data[index][1];
                }
                function listCacheHas(key) {
                    return assocIndexOf(this.__data__, key) > -1;
                }
                function listCacheSet(key, value1) {
                    var data = this.__data__, index = assocIndexOf(data, key);
                    if (index < 0) {
                        ++this.size;
                        data.push([
                            key,
                            value1
                        ]);
                    } else {
                        data[index][1] = value1;
                    }
                    return this;
                }
                ListCache.prototype.clear = listCacheClear;
                ListCache.prototype["delete"] = listCacheDelete;
                ListCache.prototype.get = listCacheGet;
                ListCache.prototype.has = listCacheHas;
                ListCache.prototype.set = listCacheSet;
                function MapCache(entries) {
                    var index = -1, length = entries == null ? 0 : entries.length;
                    this.clear();
                    while(++index < length){
                        var entry = entries[index];
                        this.set(entry[0], entry[1]);
                    }
                }
                function mapCacheClear() {
                    this.size = 0;
                    this.__data__ = {
                        "hash": new Hash(),
                        "map": new (Map2 || ListCache)(),
                        "string": new Hash()
                    };
                }
                function mapCacheDelete(key) {
                    var result2 = getMapData(this, key)["delete"](key);
                    this.size -= result2 ? 1 : 0;
                    return result2;
                }
                function mapCacheGet(key) {
                    return getMapData(this, key).get(key);
                }
                function mapCacheHas(key) {
                    return getMapData(this, key).has(key);
                }
                function mapCacheSet(key, value1) {
                    var data = getMapData(this, key), size2 = data.size;
                    data.set(key, value1);
                    this.size += data.size == size2 ? 0 : 1;
                    return this;
                }
                MapCache.prototype.clear = mapCacheClear;
                MapCache.prototype["delete"] = mapCacheDelete;
                MapCache.prototype.get = mapCacheGet;
                MapCache.prototype.has = mapCacheHas;
                MapCache.prototype.set = mapCacheSet;
                function SetCache(values2) {
                    var index = -1, length = values2 == null ? 0 : values2.length;
                    this.__data__ = new MapCache();
                    while(++index < length){
                        this.add(values2[index]);
                    }
                }
                function setCacheAdd(value1) {
                    this.__data__.set(value1, HASH_UNDEFINED);
                    return this;
                }
                function setCacheHas(value1) {
                    return this.__data__.has(value1);
                }
                SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
                SetCache.prototype.has = setCacheHas;
                function Stack(entries) {
                    var data = this.__data__ = new ListCache(entries);
                    this.size = data.size;
                }
                function stackClear() {
                    this.__data__ = new ListCache();
                    this.size = 0;
                }
                function stackDelete(key) {
                    var data = this.__data__, result2 = data["delete"](key);
                    this.size = data.size;
                    return result2;
                }
                function stackGet(key) {
                    return this.__data__.get(key);
                }
                function stackHas(key) {
                    return this.__data__.has(key);
                }
                function stackSet(key, value1) {
                    var data = this.__data__;
                    if (data instanceof ListCache) {
                        var pairs2 = data.__data__;
                        if (!Map2 || pairs2.length < LARGE_ARRAY_SIZE - 1) {
                            pairs2.push([
                                key,
                                value1
                            ]);
                            this.size = ++data.size;
                            return this;
                        }
                        data = this.__data__ = new MapCache(pairs2);
                    }
                    data.set(key, value1);
                    this.size = data.size;
                    return this;
                }
                Stack.prototype.clear = stackClear;
                Stack.prototype["delete"] = stackDelete;
                Stack.prototype.get = stackGet;
                Stack.prototype.has = stackHas;
                Stack.prototype.set = stackSet;
                function arrayLikeKeys(value1, inherited) {
                    var isArr = isArray(value1), isArg = !isArr && isArguments(value1), isBuff = !isArr && !isArg && isBuffer(value1), isType = !isArr && !isArg && !isBuff && isTypedArray(value1), skipIndexes = isArr || isArg || isBuff || isType, result2 = skipIndexes ? baseTimes(value1.length, String2) : [], length = result2.length;
                    for(var key in value1){
                        if ((inherited || hasOwnProperty.call(value1, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
                        (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
                        isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
                        isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
                        isIndex(key, length)))) {
                            result2.push(key);
                        }
                    }
                    return result2;
                }
                function arraySample(array) {
                    var length = array.length;
                    return length ? array[baseRandom(0, length - 1)] : undefined2;
                }
                function arraySampleSize(array, n) {
                    return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
                }
                function arrayShuffle(array) {
                    return shuffleSelf(copyArray(array));
                }
                function assignMergeValue(object, key, value1) {
                    if (value1 !== undefined2 && !eq(object[key], value1) || value1 === undefined2 && !(key in object)) {
                        baseAssignValue(object, key, value1);
                    }
                }
                function assignValue(object, key, value1) {
                    var objValue = object[key];
                    if (!(hasOwnProperty.call(object, key) && eq(objValue, value1)) || value1 === undefined2 && !(key in object)) {
                        baseAssignValue(object, key, value1);
                    }
                }
                function assocIndexOf(array, key) {
                    var length = array.length;
                    while(length--){
                        if (eq(array[length][0], key)) {
                            return length;
                        }
                    }
                    return -1;
                }
                function baseAggregator(collection, setter, iteratee2, accumulator) {
                    baseEach(collection, function(value1, key, collection2) {
                        setter(accumulator, value1, iteratee2(value1), collection2);
                    });
                    return accumulator;
                }
                function baseAssign(object, source) {
                    return object && copyObject(source, keys(source), object);
                }
                function baseAssignIn(object, source) {
                    return object && copyObject(source, keysIn(source), object);
                }
                function baseAssignValue(object, key, value1) {
                    if (key == "__proto__" && defineProperty) {
                        defineProperty(object, key, {
                            "configurable": true,
                            "enumerable": true,
                            "value": value1,
                            "writable": true
                        });
                    } else {
                        object[key] = value1;
                    }
                }
                function baseAt(object, paths) {
                    var index = -1, length = paths.length, result2 = Array2(length), skip = object == null;
                    while(++index < length){
                        result2[index] = skip ? undefined2 : get(object, paths[index]);
                    }
                    return result2;
                }
                function baseClamp(number, lower, upper) {
                    if (number === number) {
                        if (upper !== undefined2) {
                            number = number <= upper ? number : upper;
                        }
                        if (lower !== undefined2) {
                            number = number >= lower ? number : lower;
                        }
                    }
                    return number;
                }
                function baseClone(value1, bitmask, customizer, key, object, stack) {
                    var result2, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
                    if (customizer) {
                        result2 = object ? customizer(value1, key, object, stack) : customizer(value1);
                    }
                    if (result2 !== undefined2) {
                        return result2;
                    }
                    if (!isObject(value1)) {
                        return value1;
                    }
                    var isArr = isArray(value1);
                    if (isArr) {
                        result2 = initCloneArray(value1);
                        if (!isDeep) {
                            return copyArray(value1, result2);
                        }
                    } else {
                        var tag = getTag(value1), isFunc = tag == funcTag || tag == genTag;
                        if (isBuffer(value1)) {
                            return cloneBuffer(value1, isDeep);
                        }
                        if (tag == objectTag || tag == argsTag || isFunc && !object) {
                            result2 = isFlat || isFunc ? {} : initCloneObject(value1);
                            if (!isDeep) {
                                return isFlat ? copySymbolsIn(value1, baseAssignIn(result2, value1)) : copySymbols(value1, baseAssign(result2, value1));
                            }
                        } else {
                            if (!cloneableTags[tag]) {
                                return object ? value1 : {};
                            }
                            result2 = initCloneByTag(value1, tag, isDeep);
                        }
                    }
                    stack || (stack = new Stack());
                    var stacked = stack.get(value1);
                    if (stacked) {
                        return stacked;
                    }
                    stack.set(value1, result2);
                    if (isSet(value1)) {
                        value1.forEach(function(subValue) {
                            result2.add(baseClone(subValue, bitmask, customizer, subValue, value1, stack));
                        });
                    } else if (isMap2(value1)) {
                        value1.forEach(function(subValue, key2) {
                            result2.set(key2, baseClone(subValue, bitmask, customizer, key2, value1, stack));
                        });
                    }
                    var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
                    var props = isArr ? undefined2 : keysFunc(value1);
                    arrayEach(props || value1, function(subValue, key2) {
                        if (props) {
                            key2 = subValue;
                            subValue = value1[key2];
                        }
                        assignValue(result2, key2, baseClone(subValue, bitmask, customizer, key2, value1, stack));
                    });
                    return result2;
                }
                function baseConforms(source) {
                    var props = keys(source);
                    return function(object) {
                        return baseConformsTo(object, source, props);
                    };
                }
                function baseConformsTo(object, source, props) {
                    var length = props.length;
                    if (object == null) {
                        return !length;
                    }
                    object = Object2(object);
                    while(length--){
                        var key = props[length], predicate = source[key], value1 = object[key];
                        if (value1 === undefined2 && !(key in object) || !predicate(value1)) {
                            return false;
                        }
                    }
                    return true;
                }
                function baseDelay(func, wait, args) {
                    if (typeof func != "function") {
                        throw new TypeError2(FUNC_ERROR_TEXT);
                    }
                    return setTimeout2(function() {
                        func.apply(undefined2, args);
                    }, wait);
                }
                function baseDifference(array, values2, iteratee2, comparator) {
                    var index = -1, includes2 = arrayIncludes, isCommon = true, length = array.length, result2 = [], valuesLength = values2.length;
                    if (!length) {
                        return result2;
                    }
                    if (iteratee2) {
                        values2 = arrayMap(values2, baseUnary(iteratee2));
                    }
                    if (comparator) {
                        includes2 = arrayIncludesWith;
                        isCommon = false;
                    } else if (values2.length >= LARGE_ARRAY_SIZE) {
                        includes2 = cacheHas;
                        isCommon = false;
                        values2 = new SetCache(values2);
                    }
                    outer: while(++index < length){
                        var value1 = array[index], computed = iteratee2 == null ? value1 : iteratee2(value1);
                        value1 = comparator || value1 !== 0 ? value1 : 0;
                        if (isCommon && computed === computed) {
                            var valuesIndex = valuesLength;
                            while(valuesIndex--){
                                if (values2[valuesIndex] === computed) {
                                    continue outer;
                                }
                            }
                            result2.push(value1);
                        } else if (!includes2(values2, computed, comparator)) {
                            result2.push(value1);
                        }
                    }
                    return result2;
                }
                var baseEach = createBaseEach(baseForOwn);
                var baseEachRight = createBaseEach(baseForOwnRight, true);
                function baseEvery(collection, predicate) {
                    var result2 = true;
                    baseEach(collection, function(value1, index, collection2) {
                        result2 = !!predicate(value1, index, collection2);
                        return result2;
                    });
                    return result2;
                }
                function baseExtremum(array, iteratee2, comparator) {
                    var index = -1, length = array.length;
                    while(++index < length){
                        var value1 = array[index], current = iteratee2(value1);
                        if (current != null && (computed === undefined2 ? current === current && !isSymbol(current) : comparator(current, computed))) {
                            var computed = current, result2 = value1;
                        }
                    }
                    return result2;
                }
                function baseFill(array, value1, start, end) {
                    var length = array.length;
                    start = toInteger(start);
                    if (start < 0) {
                        start = -start > length ? 0 : length + start;
                    }
                    end = end === undefined2 || end > length ? length : toInteger(end);
                    if (end < 0) {
                        end += length;
                    }
                    end = start > end ? 0 : toLength(end);
                    while(start < end){
                        array[start++] = value1;
                    }
                    return array;
                }
                function baseFilter(collection, predicate) {
                    var result2 = [];
                    baseEach(collection, function(value1, index, collection2) {
                        if (predicate(value1, index, collection2)) {
                            result2.push(value1);
                        }
                    });
                    return result2;
                }
                function baseFlatten(array, depth, predicate, isStrict, result2) {
                    var index = -1, length = array.length;
                    predicate || (predicate = isFlattenable);
                    result2 || (result2 = []);
                    while(++index < length){
                        var value1 = array[index];
                        if (depth > 0 && predicate(value1)) {
                            if (depth > 1) {
                                baseFlatten(value1, depth - 1, predicate, isStrict, result2);
                            } else {
                                arrayPush(result2, value1);
                            }
                        } else if (!isStrict) {
                            result2[result2.length] = value1;
                        }
                    }
                    return result2;
                }
                var baseFor = createBaseFor();
                var baseForRight = createBaseFor(true);
                function baseForOwn(object, iteratee2) {
                    return object && baseFor(object, iteratee2, keys);
                }
                function baseForOwnRight(object, iteratee2) {
                    return object && baseForRight(object, iteratee2, keys);
                }
                function baseFunctions(object, props) {
                    return arrayFilter(props, function(key) {
                        return isFunction(object[key]);
                    });
                }
                function baseGet(object, path5) {
                    path5 = castPath(path5, object);
                    var index = 0, length = path5.length;
                    while(object != null && index < length){
                        object = object[toKey(path5[index++])];
                    }
                    return index && index == length ? object : undefined2;
                }
                function baseGetAllKeys(object, keysFunc, symbolsFunc) {
                    var result2 = keysFunc(object);
                    return isArray(object) ? result2 : arrayPush(result2, symbolsFunc(object));
                }
                function baseGetTag(value1) {
                    if (value1 == null) {
                        return value1 === undefined2 ? undefinedTag : nullTag2;
                    }
                    return symToStringTag && symToStringTag in Object2(value1) ? getRawTag(value1) : objectToString(value1);
                }
                function baseGt(value1, other) {
                    return value1 > other;
                }
                function baseHas(object, key) {
                    return object != null && hasOwnProperty.call(object, key);
                }
                function baseHasIn(object, key) {
                    return object != null && key in Object2(object);
                }
                function baseInRange(number, start, end) {
                    return number >= nativeMin(start, end) && number < nativeMax(start, end);
                }
                function baseIntersection(arrays, iteratee2, comparator) {
                    var includes2 = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array2(othLength), maxLength = Infinity, result2 = [];
                    while(othIndex--){
                        var array = arrays[othIndex];
                        if (othIndex && iteratee2) {
                            array = arrayMap(array, baseUnary(iteratee2));
                        }
                        maxLength = nativeMin(array.length, maxLength);
                        caches[othIndex] = !comparator && (iteratee2 || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : undefined2;
                    }
                    array = arrays[0];
                    var index = -1, seen = caches[0];
                    outer: while(++index < length && result2.length < maxLength){
                        var value1 = array[index], computed = iteratee2 ? iteratee2(value1) : value1;
                        value1 = comparator || value1 !== 0 ? value1 : 0;
                        if (!(seen ? cacheHas(seen, computed) : includes2(result2, computed, comparator))) {
                            othIndex = othLength;
                            while(--othIndex){
                                var cache = caches[othIndex];
                                if (!(cache ? cacheHas(cache, computed) : includes2(arrays[othIndex], computed, comparator))) {
                                    continue outer;
                                }
                            }
                            if (seen) {
                                seen.push(computed);
                            }
                            result2.push(value1);
                        }
                    }
                    return result2;
                }
                function baseInverter(object, setter, iteratee2, accumulator) {
                    baseForOwn(object, function(value1, key, object2) {
                        setter(accumulator, iteratee2(value1), key, object2);
                    });
                    return accumulator;
                }
                function baseInvoke(object, path5, args) {
                    path5 = castPath(path5, object);
                    object = parent(object, path5);
                    var func = object == null ? object : object[toKey(last(path5))];
                    return func == null ? undefined2 : apply(func, object, args);
                }
                function baseIsArguments(value1) {
                    return isObjectLike(value1) && baseGetTag(value1) == argsTag;
                }
                function baseIsArrayBuffer(value1) {
                    return isObjectLike(value1) && baseGetTag(value1) == arrayBufferTag;
                }
                function baseIsDate(value1) {
                    return isObjectLike(value1) && baseGetTag(value1) == dateTag;
                }
                function baseIsEqual(value1, other, bitmask, customizer, stack) {
                    if (value1 === other) {
                        return true;
                    }
                    if (value1 == null || other == null || !isObjectLike(value1) && !isObjectLike(other)) {
                        return value1 !== value1 && other !== other;
                    }
                    return baseIsEqualDeep(value1, other, bitmask, customizer, baseIsEqual, stack);
                }
                function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
                    var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
                    objTag = objTag == argsTag ? objectTag : objTag;
                    othTag = othTag == argsTag ? objectTag : othTag;
                    var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
                    if (isSameTag && isBuffer(object)) {
                        if (!isBuffer(other)) {
                            return false;
                        }
                        objIsArr = true;
                        objIsObj = false;
                    }
                    if (isSameTag && !objIsObj) {
                        stack || (stack = new Stack());
                        return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
                    }
                    if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
                        var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
                        if (objIsWrapped || othIsWrapped) {
                            var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
                            stack || (stack = new Stack());
                            return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
                        }
                    }
                    if (!isSameTag) {
                        return false;
                    }
                    stack || (stack = new Stack());
                    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
                }
                function baseIsMap(value1) {
                    return isObjectLike(value1) && getTag(value1) == mapTag;
                }
                function baseIsMatch(object, source, matchData, customizer) {
                    var index = matchData.length, length = index, noCustomizer = !customizer;
                    if (object == null) {
                        return !length;
                    }
                    object = Object2(object);
                    while(index--){
                        var data = matchData[index];
                        if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
                            return false;
                        }
                    }
                    while(++index < length){
                        data = matchData[index];
                        var key = data[0], objValue = object[key], srcValue = data[1];
                        if (noCustomizer && data[2]) {
                            if (objValue === undefined2 && !(key in object)) {
                                return false;
                            }
                        } else {
                            var stack = new Stack();
                            if (customizer) {
                                var result2 = customizer(objValue, srcValue, key, object, source, stack);
                            }
                            if (!(result2 === undefined2 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result2)) {
                                return false;
                            }
                        }
                    }
                    return true;
                }
                function baseIsNative(value1) {
                    if (!isObject(value1) || isMasked(value1)) {
                        return false;
                    }
                    var pattern = isFunction(value1) ? reIsNative : reIsHostCtor;
                    return pattern.test(toSource(value1));
                }
                function baseIsRegExp(value1) {
                    return isObjectLike(value1) && baseGetTag(value1) == regexpTag;
                }
                function baseIsSet(value1) {
                    return isObjectLike(value1) && getTag(value1) == setTag;
                }
                function baseIsTypedArray(value1) {
                    return isObjectLike(value1) && isLength(value1.length) && !!typedArrayTags[baseGetTag(value1)];
                }
                function baseIteratee(value1) {
                    if (typeof value1 == "function") {
                        return value1;
                    }
                    if (value1 == null) {
                        return identity;
                    }
                    if (typeof value1 == "object") {
                        return isArray(value1) ? baseMatchesProperty(value1[0], value1[1]) : baseMatches(value1);
                    }
                    return property(value1);
                }
                function baseKeys(object) {
                    if (!isPrototype(object)) {
                        return nativeKeys(object);
                    }
                    var result2 = [];
                    for(var key in Object2(object)){
                        if (hasOwnProperty.call(object, key) && key != "constructor") {
                            result2.push(key);
                        }
                    }
                    return result2;
                }
                function baseKeysIn(object) {
                    if (!isObject(object)) {
                        return nativeKeysIn(object);
                    }
                    var isProto = isPrototype(object), result2 = [];
                    for(var key in object){
                        if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) {
                            result2.push(key);
                        }
                    }
                    return result2;
                }
                function baseLt(value1, other) {
                    return value1 < other;
                }
                function baseMap(collection, iteratee2) {
                    var index = -1, result2 = isArrayLike(collection) ? Array2(collection.length) : [];
                    baseEach(collection, function(value1, key, collection2) {
                        result2[++index] = iteratee2(value1, key, collection2);
                    });
                    return result2;
                }
                function baseMatches(source) {
                    var matchData = getMatchData(source);
                    if (matchData.length == 1 && matchData[0][2]) {
                        return matchesStrictComparable(matchData[0][0], matchData[0][1]);
                    }
                    return function(object) {
                        return object === source || baseIsMatch(object, source, matchData);
                    };
                }
                function baseMatchesProperty(path5, srcValue) {
                    if (isKey(path5) && isStrictComparable(srcValue)) {
                        return matchesStrictComparable(toKey(path5), srcValue);
                    }
                    return function(object) {
                        var objValue = get(object, path5);
                        return objValue === undefined2 && objValue === srcValue ? hasIn(object, path5) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
                    };
                }
                function baseMerge(object, source, srcIndex, customizer, stack) {
                    if (object === source) {
                        return;
                    }
                    baseFor(source, function(srcValue, key) {
                        stack || (stack = new Stack());
                        if (isObject(srcValue)) {
                            baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
                        } else {
                            var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : undefined2;
                            if (newValue === undefined2) {
                                newValue = srcValue;
                            }
                            assignMergeValue(object, key, newValue);
                        }
                    }, keysIn);
                }
                function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
                    var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
                    if (stacked) {
                        assignMergeValue(object, key, stacked);
                        return;
                    }
                    var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : undefined2;
                    var isCommon = newValue === undefined2;
                    if (isCommon) {
                        var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
                        newValue = srcValue;
                        if (isArr || isBuff || isTyped) {
                            if (isArray(objValue)) {
                                newValue = objValue;
                            } else if (isArrayLikeObject(objValue)) {
                                newValue = copyArray(objValue);
                            } else if (isBuff) {
                                isCommon = false;
                                newValue = cloneBuffer(srcValue, true);
                            } else if (isTyped) {
                                isCommon = false;
                                newValue = cloneTypedArray(srcValue, true);
                            } else {
                                newValue = [];
                            }
                        } else if (isPlainObject(srcValue) || isArguments(srcValue)) {
                            newValue = objValue;
                            if (isArguments(objValue)) {
                                newValue = toPlainObject(objValue);
                            } else if (!isObject(objValue) || isFunction(objValue)) {
                                newValue = initCloneObject(srcValue);
                            }
                        } else {
                            isCommon = false;
                        }
                    }
                    if (isCommon) {
                        stack.set(srcValue, newValue);
                        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
                        stack["delete"](srcValue);
                    }
                    assignMergeValue(object, key, newValue);
                }
                function baseNth(array, n) {
                    var length = array.length;
                    if (!length) {
                        return;
                    }
                    n += n < 0 ? length : 0;
                    return isIndex(n, length) ? array[n] : undefined2;
                }
                function baseOrderBy(collection, iteratees, orders) {
                    if (iteratees.length) {
                        iteratees = arrayMap(iteratees, function(iteratee2) {
                            if (isArray(iteratee2)) {
                                return function(value1) {
                                    return baseGet(value1, iteratee2.length === 1 ? iteratee2[0] : iteratee2);
                                };
                            }
                            return iteratee2;
                        });
                    } else {
                        iteratees = [
                            identity
                        ];
                    }
                    var index = -1;
                    iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
                    var result2 = baseMap(collection, function(value1, key, collection2) {
                        var criteria = arrayMap(iteratees, function(iteratee2) {
                            return iteratee2(value1);
                        });
                        return {
                            "criteria": criteria,
                            "index": ++index,
                            "value": value1
                        };
                    });
                    return baseSortBy(result2, function(object, other) {
                        return compareMultiple(object, other, orders);
                    });
                }
                function basePick(object, paths) {
                    return basePickBy(object, paths, function(value1, path5) {
                        return hasIn(object, path5);
                    });
                }
                function basePickBy(object, paths, predicate) {
                    var index = -1, length = paths.length, result2 = {};
                    while(++index < length){
                        var path5 = paths[index], value1 = baseGet(object, path5);
                        if (predicate(value1, path5)) {
                            baseSet(result2, castPath(path5, object), value1);
                        }
                    }
                    return result2;
                }
                function basePropertyDeep(path5) {
                    return function(object) {
                        return baseGet(object, path5);
                    };
                }
                function basePullAll(array, values2, iteratee2, comparator) {
                    var indexOf3 = comparator ? baseIndexOfWith : baseIndexOf, index = -1, length = values2.length, seen = array;
                    if (array === values2) {
                        values2 = copyArray(values2);
                    }
                    if (iteratee2) {
                        seen = arrayMap(array, baseUnary(iteratee2));
                    }
                    while(++index < length){
                        var fromIndex = 0, value1 = values2[index], computed = iteratee2 ? iteratee2(value1) : value1;
                        while((fromIndex = indexOf3(seen, computed, fromIndex, comparator)) > -1){
                            if (seen !== array) {
                                splice.call(seen, fromIndex, 1);
                            }
                            splice.call(array, fromIndex, 1);
                        }
                    }
                    return array;
                }
                function basePullAt(array, indexes) {
                    var length = array ? indexes.length : 0, lastIndex = length - 1;
                    while(length--){
                        var index = indexes[length];
                        if (length == lastIndex || index !== previous) {
                            var previous = index;
                            if (isIndex(index)) {
                                splice.call(array, index, 1);
                            } else {
                                baseUnset(array, index);
                            }
                        }
                    }
                    return array;
                }
                function baseRandom(lower, upper) {
                    return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
                }
                function baseRange(start, end, step, fromRight) {
                    var index = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result2 = Array2(length);
                    while(length--){
                        result2[fromRight ? length : ++index] = start;
                        start += step;
                    }
                    return result2;
                }
                function baseRepeat(string2, n) {
                    var result2 = "";
                    if (!string2 || n < 1 || n > MAX_SAFE_INTEGER) {
                        return result2;
                    }
                    do {
                        if (n % 2) {
                            result2 += string2;
                        }
                        n = nativeFloor(n / 2);
                        if (n) {
                            string2 += string2;
                        }
                    }while (n)
                    return result2;
                }
                function baseRest(func, start) {
                    return setToString(overRest(func, start, identity), func + "");
                }
                function baseSample(collection) {
                    return arraySample(values(collection));
                }
                function baseSampleSize(collection, n) {
                    var array = values(collection);
                    return shuffleSelf(array, baseClamp(n, 0, array.length));
                }
                function baseSet(object, path5, value1, customizer) {
                    if (!isObject(object)) {
                        return object;
                    }
                    path5 = castPath(path5, object);
                    var index = -1, length = path5.length, lastIndex = length - 1, nested = object;
                    while(nested != null && ++index < length){
                        var key = toKey(path5[index]), newValue = value1;
                        if (key === "__proto__" || key === "constructor" || key === "prototype") {
                            return object;
                        }
                        if (index != lastIndex) {
                            var objValue = nested[key];
                            newValue = customizer ? customizer(objValue, key, nested) : undefined2;
                            if (newValue === undefined2) {
                                newValue = isObject(objValue) ? objValue : isIndex(path5[index + 1]) ? [] : {};
                            }
                        }
                        assignValue(nested, key, newValue);
                        nested = nested[key];
                    }
                    return object;
                }
                var baseSetData = !metaMap ? identity : function(func, data) {
                    metaMap.set(func, data);
                    return func;
                };
                var baseSetToString = !defineProperty ? identity : function(func, string2) {
                    return defineProperty(func, "toString", {
                        "configurable": true,
                        "enumerable": false,
                        "value": constant(string2),
                        "writable": true
                    });
                };
                function baseShuffle(collection) {
                    return shuffleSelf(values(collection));
                }
                function baseSlice(array, start, end) {
                    var index = -1, length = array.length;
                    if (start < 0) {
                        start = -start > length ? 0 : length + start;
                    }
                    end = end > length ? length : end;
                    if (end < 0) {
                        end += length;
                    }
                    length = start > end ? 0 : end - start >>> 0;
                    start >>>= 0;
                    var result2 = Array2(length);
                    while(++index < length){
                        result2[index] = array[index + start];
                    }
                    return result2;
                }
                function baseSome(collection, predicate) {
                    var result2;
                    baseEach(collection, function(value1, index, collection2) {
                        result2 = predicate(value1, index, collection2);
                        return !result2;
                    });
                    return !!result2;
                }
                function baseSortedIndex(array, value1, retHighest) {
                    var low = 0, high = array == null ? low : array.length;
                    if (typeof value1 == "number" && value1 === value1 && high <= HALF_MAX_ARRAY_LENGTH) {
                        while(low < high){
                            var mid = low + high >>> 1, computed = array[mid];
                            if (computed !== null && !isSymbol(computed) && (retHighest ? computed <= value1 : computed < value1)) {
                                low = mid + 1;
                            } else {
                                high = mid;
                            }
                        }
                        return high;
                    }
                    return baseSortedIndexBy(array, value1, identity, retHighest);
                }
                function baseSortedIndexBy(array, value1, iteratee2, retHighest) {
                    var low = 0, high = array == null ? 0 : array.length;
                    if (high === 0) {
                        return 0;
                    }
                    value1 = iteratee2(value1);
                    var valIsNaN = value1 !== value1, valIsNull = value1 === null, valIsSymbol = isSymbol(value1), valIsUndefined = value1 === undefined2;
                    while(low < high){
                        var mid = nativeFloor((low + high) / 2), computed = iteratee2(array[mid]), othIsDefined = computed !== undefined2, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed);
                        if (valIsNaN) {
                            var setLow = retHighest || othIsReflexive;
                        } else if (valIsUndefined) {
                            setLow = othIsReflexive && (retHighest || othIsDefined);
                        } else if (valIsNull) {
                            setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
                        } else if (valIsSymbol) {
                            setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
                        } else if (othIsNull || othIsSymbol) {
                            setLow = false;
                        } else {
                            setLow = retHighest ? computed <= value1 : computed < value1;
                        }
                        if (setLow) {
                            low = mid + 1;
                        } else {
                            high = mid;
                        }
                    }
                    return nativeMin(high, MAX_ARRAY_INDEX);
                }
                function baseSortedUniq(array, iteratee2) {
                    var index = -1, length = array.length, resIndex = 0, result2 = [];
                    while(++index < length){
                        var value1 = array[index], computed = iteratee2 ? iteratee2(value1) : value1;
                        if (!index || !eq(computed, seen)) {
                            var seen = computed;
                            result2[resIndex++] = value1 === 0 ? 0 : value1;
                        }
                    }
                    return result2;
                }
                function baseToNumber(value1) {
                    if (typeof value1 == "number") {
                        return value1;
                    }
                    if (isSymbol(value1)) {
                        return NAN;
                    }
                    return +value1;
                }
                function baseToString(value1) {
                    if (typeof value1 == "string") {
                        return value1;
                    }
                    if (isArray(value1)) {
                        return arrayMap(value1, baseToString) + "";
                    }
                    if (isSymbol(value1)) {
                        return symbolToString ? symbolToString.call(value1) : "";
                    }
                    var result2 = value1 + "";
                    return result2 == "0" && 1 / value1 == -INFINITY ? "-0" : result2;
                }
                function baseUniq(array, iteratee2, comparator) {
                    var index = -1, includes2 = arrayIncludes, length = array.length, isCommon = true, result2 = [], seen = result2;
                    if (comparator) {
                        isCommon = false;
                        includes2 = arrayIncludesWith;
                    } else if (length >= LARGE_ARRAY_SIZE) {
                        var set3 = iteratee2 ? null : createSet(array);
                        if (set3) {
                            return setToArray(set3);
                        }
                        isCommon = false;
                        includes2 = cacheHas;
                        seen = new SetCache();
                    } else {
                        seen = iteratee2 ? [] : result2;
                    }
                    outer: while(++index < length){
                        var value1 = array[index], computed = iteratee2 ? iteratee2(value1) : value1;
                        value1 = comparator || value1 !== 0 ? value1 : 0;
                        if (isCommon && computed === computed) {
                            var seenIndex = seen.length;
                            while(seenIndex--){
                                if (seen[seenIndex] === computed) {
                                    continue outer;
                                }
                            }
                            if (iteratee2) {
                                seen.push(computed);
                            }
                            result2.push(value1);
                        } else if (!includes2(seen, computed, comparator)) {
                            if (seen !== result2) {
                                seen.push(computed);
                            }
                            result2.push(value1);
                        }
                    }
                    return result2;
                }
                function baseUnset(object, path5) {
                    path5 = castPath(path5, object);
                    object = parent(object, path5);
                    return object == null || delete object[toKey(last(path5))];
                }
                function baseUpdate(object, path5, updater, customizer) {
                    return baseSet(object, path5, updater(baseGet(object, path5)), customizer);
                }
                function baseWhile(array, predicate, isDrop, fromRight) {
                    var length = array.length, index = fromRight ? length : -1;
                    while((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)){}
                    return isDrop ? baseSlice(array, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice(array, fromRight ? index + 1 : 0, fromRight ? length : index);
                }
                function baseWrapperValue(value1, actions) {
                    var result2 = value1;
                    if (result2 instanceof LazyWrapper) {
                        result2 = result2.value();
                    }
                    return arrayReduce(actions, function(result3, action) {
                        return action.func.apply(action.thisArg, arrayPush([
                            result3
                        ], action.args));
                    }, result2);
                }
                function baseXor(arrays, iteratee2, comparator) {
                    var length = arrays.length;
                    if (length < 2) {
                        return length ? baseUniq(arrays[0]) : [];
                    }
                    var index = -1, result2 = Array2(length);
                    while(++index < length){
                        var array = arrays[index], othIndex = -1;
                        while(++othIndex < length){
                            if (othIndex != index) {
                                result2[index] = baseDifference(result2[index] || array, arrays[othIndex], iteratee2, comparator);
                            }
                        }
                    }
                    return baseUniq(baseFlatten(result2, 1), iteratee2, comparator);
                }
                function baseZipObject(props, values2, assignFunc) {
                    var index = -1, length = props.length, valsLength = values2.length, result2 = {};
                    while(++index < length){
                        var value1 = index < valsLength ? values2[index] : undefined2;
                        assignFunc(result2, props[index], value1);
                    }
                    return result2;
                }
                function castArrayLikeObject(value1) {
                    return isArrayLikeObject(value1) ? value1 : [];
                }
                function castFunction(value1) {
                    return typeof value1 == "function" ? value1 : identity;
                }
                function castPath(value1, object) {
                    if (isArray(value1)) {
                        return value1;
                    }
                    return isKey(value1, object) ? [
                        value1
                    ] : stringToPath(toString(value1));
                }
                var castRest = baseRest;
                function castSlice(array, start, end) {
                    var length = array.length;
                    end = end === undefined2 ? length : end;
                    return !start && end >= length ? array : baseSlice(array, start, end);
                }
                var clearTimeout2 = ctxClearTimeout || function(id) {
                    return root.clearTimeout(id);
                };
                function cloneBuffer(buffer, isDeep) {
                    if (isDeep) {
                        return buffer.slice();
                    }
                    var length = buffer.length, result2 = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
                    buffer.copy(result2);
                    return result2;
                }
                function cloneArrayBuffer(arrayBuffer) {
                    var result2 = new arrayBuffer.constructor(arrayBuffer.byteLength);
                    new Uint8Array2(result2).set(new Uint8Array2(arrayBuffer));
                    return result2;
                }
                function cloneDataView(dataView, isDeep) {
                    var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
                    return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
                }
                function cloneRegExp(regexp) {
                    var result2 = new regexp.constructor(regexp.source, reFlags.exec(regexp));
                    result2.lastIndex = regexp.lastIndex;
                    return result2;
                }
                function cloneSymbol(symbol) {
                    return symbolValueOf ? Object2(symbolValueOf.call(symbol)) : {};
                }
                function cloneTypedArray(typedArray, isDeep) {
                    var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
                    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
                }
                function compareAscending(value1, other) {
                    if (value1 !== other) {
                        var valIsDefined = value1 !== undefined2, valIsNull = value1 === null, valIsReflexive = value1 === value1, valIsSymbol = isSymbol(value1);
                        var othIsDefined = other !== undefined2, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
                        if (!othIsNull && !othIsSymbol && !valIsSymbol && value1 > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
                            return 1;
                        }
                        if (!valIsNull && !valIsSymbol && !othIsSymbol && value1 < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
                            return -1;
                        }
                    }
                    return 0;
                }
                function compareMultiple(object, other, orders) {
                    var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
                    while(++index < length){
                        var result2 = compareAscending(objCriteria[index], othCriteria[index]);
                        if (result2) {
                            if (index >= ordersLength) {
                                return result2;
                            }
                            var order = orders[index];
                            return result2 * (order == "desc" ? -1 : 1);
                        }
                    }
                    return object.index - other.index;
                }
                function composeArgs(args, partials, holders, isCurried) {
                    var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(leftLength + rangeLength), isUncurried = !isCurried;
                    while(++leftIndex < leftLength){
                        result2[leftIndex] = partials[leftIndex];
                    }
                    while(++argsIndex < holdersLength){
                        if (isUncurried || argsIndex < argsLength) {
                            result2[holders[argsIndex]] = args[argsIndex];
                        }
                    }
                    while(rangeLength--){
                        result2[leftIndex++] = args[argsIndex++];
                    }
                    return result2;
                }
                function composeArgsRight(args, partials, holders, isCurried) {
                    var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(rangeLength + rightLength), isUncurried = !isCurried;
                    while(++argsIndex < rangeLength){
                        result2[argsIndex] = args[argsIndex];
                    }
                    var offset = argsIndex;
                    while(++rightIndex < rightLength){
                        result2[offset + rightIndex] = partials[rightIndex];
                    }
                    while(++holdersIndex < holdersLength){
                        if (isUncurried || argsIndex < argsLength) {
                            result2[offset + holders[holdersIndex]] = args[argsIndex++];
                        }
                    }
                    return result2;
                }
                function copyArray(source, array) {
                    var index = -1, length = source.length;
                    array || (array = Array2(length));
                    while(++index < length){
                        array[index] = source[index];
                    }
                    return array;
                }
                function copyObject(source, props, object, customizer) {
                    var isNew = !object;
                    object || (object = {});
                    var index = -1, length = props.length;
                    while(++index < length){
                        var key = props[index];
                        var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined2;
                        if (newValue === undefined2) {
                            newValue = source[key];
                        }
                        if (isNew) {
                            baseAssignValue(object, key, newValue);
                        } else {
                            assignValue(object, key, newValue);
                        }
                    }
                    return object;
                }
                function copySymbols(source, object) {
                    return copyObject(source, getSymbols(source), object);
                }
                function copySymbolsIn(source, object) {
                    return copyObject(source, getSymbolsIn(source), object);
                }
                function createAggregator(setter, initializer) {
                    return function(collection, iteratee2) {
                        var func = isArray(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {};
                        return func(collection, setter, getIteratee(iteratee2, 2), accumulator);
                    };
                }
                function createAssigner(assigner) {
                    return baseRest(function(object, sources) {
                        var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : undefined2, guard = length > 2 ? sources[2] : undefined2;
                        customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : undefined2;
                        if (guard && isIterateeCall(sources[0], sources[1], guard)) {
                            customizer = length < 3 ? undefined2 : customizer;
                            length = 1;
                        }
                        object = Object2(object);
                        while(++index < length){
                            var source = sources[index];
                            if (source) {
                                assigner(object, source, index, customizer);
                            }
                        }
                        return object;
                    });
                }
                function createBaseEach(eachFunc, fromRight) {
                    return function(collection, iteratee2) {
                        if (collection == null) {
                            return collection;
                        }
                        if (!isArrayLike(collection)) {
                            return eachFunc(collection, iteratee2);
                        }
                        var length = collection.length, index = fromRight ? length : -1, iterable = Object2(collection);
                        while(fromRight ? index-- : ++index < length){
                            if (iteratee2(iterable[index], index, iterable) === false) {
                                break;
                            }
                        }
                        return collection;
                    };
                }
                function createBaseFor(fromRight) {
                    return function(object, iteratee2, keysFunc) {
                        var index = -1, iterable = Object2(object), props = keysFunc(object), length = props.length;
                        while(length--){
                            var key = props[fromRight ? length : ++index];
                            if (iteratee2(iterable[key], key, iterable) === false) {
                                break;
                            }
                        }
                        return object;
                    };
                }
                function createBind(func, bitmask, thisArg) {
                    var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
                    function wrapper() {
                        var fn = this && this !== root && this instanceof wrapper ? Ctor : func;
                        return fn.apply(isBind ? thisArg : this, arguments);
                    }
                    return wrapper;
                }
                function createCaseFirst(methodName) {
                    return function(string2) {
                        string2 = toString(string2);
                        var strSymbols = hasUnicode(string2) ? stringToArray(string2) : undefined2;
                        var chr = strSymbols ? strSymbols[0] : string2.charAt(0);
                        var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string2.slice(1);
                        return chr[methodName]() + trailing;
                    };
                }
                function createCompounder(callback) {
                    return function(string2) {
                        return arrayReduce(words(deburr(string2).replace(reApos, "")), callback, "");
                    };
                }
                function createCtor(Ctor) {
                    return function() {
                        var args = arguments;
                        switch(args.length){
                            case 0:
                                return new Ctor();
                            case 1:
                                return new Ctor(args[0]);
                            case 2:
                                return new Ctor(args[0], args[1]);
                            case 3:
                                return new Ctor(args[0], args[1], args[2]);
                            case 4:
                                return new Ctor(args[0], args[1], args[2], args[3]);
                            case 5:
                                return new Ctor(args[0], args[1], args[2], args[3], args[4]);
                            case 6:
                                return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
                            case 7:
                                return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
                        }
                        var thisBinding = baseCreate(Ctor.prototype), result2 = Ctor.apply(thisBinding, args);
                        return isObject(result2) ? result2 : thisBinding;
                    };
                }
                function createCurry(func, bitmask, arity) {
                    var Ctor = createCtor(func);
                    function wrapper() {
                        var length = arguments.length, args = Array2(length), index = length, placeholder = getHolder(wrapper);
                        while(index--){
                            args[index] = arguments[index];
                        }
                        var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder);
                        length -= holders.length;
                        if (length < arity) {
                            return createRecurry(func, bitmask, createHybrid, wrapper.placeholder, undefined2, args, holders, undefined2, undefined2, arity - length);
                        }
                        var fn = this && this !== root && this instanceof wrapper ? Ctor : func;
                        return apply(fn, this, args);
                    }
                    return wrapper;
                }
                function createFind(findIndexFunc) {
                    return function(collection, predicate, fromIndex) {
                        var iterable = Object2(collection);
                        if (!isArrayLike(collection)) {
                            var iteratee2 = getIteratee(predicate, 3);
                            collection = keys(collection);
                            predicate = function(key) {
                                return iteratee2(iterable[key], key, iterable);
                            };
                        }
                        var index = findIndexFunc(collection, predicate, fromIndex);
                        return index > -1 ? iterable[iteratee2 ? collection[index] : index] : undefined2;
                    };
                }
                function createFlow(fromRight) {
                    return flatRest(function(funcs) {
                        var length = funcs.length, index = length, prereq = LodashWrapper.prototype.thru;
                        if (fromRight) {
                            funcs.reverse();
                        }
                        while(index--){
                            var func = funcs[index];
                            if (typeof func != "function") {
                                throw new TypeError2(FUNC_ERROR_TEXT);
                            }
                            if (prereq && !wrapper && getFuncName(func) == "wrapper") {
                                var wrapper = new LodashWrapper([], true);
                            }
                        }
                        index = wrapper ? index : length;
                        while(++index < length){
                            func = funcs[index];
                            var funcName = getFuncName(func), data = funcName == "wrapper" ? getData(func) : undefined2;
                            if (data && isLaziable(data[0]) && data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && !data[4].length && data[9] == 1) {
                                wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
                            } else {
                                wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func);
                            }
                        }
                        return function() {
                            var args = arguments, value1 = args[0];
                            if (wrapper && args.length == 1 && isArray(value1)) {
                                return wrapper.plant(value1).value();
                            }
                            var index2 = 0, result2 = length ? funcs[index2].apply(this, args) : value1;
                            while(++index2 < length){
                                result2 = funcs[index2].call(this, result2);
                            }
                            return result2;
                        };
                    });
                }
                function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary2, arity) {
                    var isAry = bitmask & WRAP_ARY_FLAG, isBind = bitmask & WRAP_BIND_FLAG, isBindKey = bitmask & WRAP_BIND_KEY_FLAG, isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), isFlip = bitmask & WRAP_FLIP_FLAG, Ctor = isBindKey ? undefined2 : createCtor(func);
                    function wrapper() {
                        var length = arguments.length, args = Array2(length), index = length;
                        while(index--){
                            args[index] = arguments[index];
                        }
                        if (isCurried) {
                            var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder);
                        }
                        if (partials) {
                            args = composeArgs(args, partials, holders, isCurried);
                        }
                        if (partialsRight) {
                            args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
                        }
                        length -= holdersCount;
                        if (isCurried && length < arity) {
                            var newHolders = replaceHolders(args, placeholder);
                            return createRecurry(func, bitmask, createHybrid, wrapper.placeholder, thisArg, args, newHolders, argPos, ary2, arity - length);
                        }
                        var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func;
                        length = args.length;
                        if (argPos) {
                            args = reorder(args, argPos);
                        } else if (isFlip && length > 1) {
                            args.reverse();
                        }
                        if (isAry && ary2 < length) {
                            args.length = ary2;
                        }
                        if (this && this !== root && this instanceof wrapper) {
                            fn = Ctor || createCtor(fn);
                        }
                        return fn.apply(thisBinding, args);
                    }
                    return wrapper;
                }
                function createInverter(setter, toIteratee) {
                    return function(object, iteratee2) {
                        return baseInverter(object, setter, toIteratee(iteratee2), {});
                    };
                }
                function createMathOperation(operator, defaultValue) {
                    return function(value1, other) {
                        var result2;
                        if (value1 === undefined2 && other === undefined2) {
                            return defaultValue;
                        }
                        if (value1 !== undefined2) {
                            result2 = value1;
                        }
                        if (other !== undefined2) {
                            if (result2 === undefined2) {
                                return other;
                            }
                            if (typeof value1 == "string" || typeof other == "string") {
                                value1 = baseToString(value1);
                                other = baseToString(other);
                            } else {
                                value1 = baseToNumber(value1);
                                other = baseToNumber(other);
                            }
                            result2 = operator(value1, other);
                        }
                        return result2;
                    };
                }
                function createOver(arrayFunc) {
                    return flatRest(function(iteratees) {
                        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
                        return baseRest(function(args) {
                            var thisArg = this;
                            return arrayFunc(iteratees, function(iteratee2) {
                                return apply(iteratee2, thisArg, args);
                            });
                        });
                    });
                }
                function createPadding(length, chars) {
                    chars = chars === undefined2 ? " " : baseToString(chars);
                    var charsLength = chars.length;
                    if (charsLength < 2) {
                        return charsLength ? baseRepeat(chars, length) : chars;
                    }
                    var result2 = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
                    return hasUnicode(chars) ? castSlice(stringToArray(result2), 0, length).join("") : result2.slice(0, length);
                }
                function createPartial(func, bitmask, thisArg, partials) {
                    var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
                    function wrapper() {
                        var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array2(leftLength + argsLength), fn = this && this !== root && this instanceof wrapper ? Ctor : func;
                        while(++leftIndex < leftLength){
                            args[leftIndex] = partials[leftIndex];
                        }
                        while(argsLength--){
                            args[leftIndex++] = arguments[++argsIndex];
                        }
                        return apply(fn, isBind ? thisArg : this, args);
                    }
                    return wrapper;
                }
                function createRange3(fromRight) {
                    return function(start, end, step) {
                        if (step && typeof step != "number" && isIterateeCall(start, end, step)) {
                            end = step = undefined2;
                        }
                        start = toFinite(start);
                        if (end === undefined2) {
                            end = start;
                            start = 0;
                        } else {
                            end = toFinite(end);
                        }
                        step = step === undefined2 ? start < end ? 1 : -1 : toFinite(step);
                        return baseRange(start, end, step, fromRight);
                    };
                }
                function createRelationalOperation(operator) {
                    return function(value1, other) {
                        if (!(typeof value1 == "string" && typeof other == "string")) {
                            value1 = toNumber(value1);
                            other = toNumber(other);
                        }
                        return operator(value1, other);
                    };
                }
                function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary2, arity) {
                    var isCurry = bitmask & WRAP_CURRY_FLAG, newHolders = isCurry ? holders : undefined2, newHoldersRight = isCurry ? undefined2 : holders, newPartials = isCurry ? partials : undefined2, newPartialsRight = isCurry ? undefined2 : partials;
                    bitmask |= isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG;
                    bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
                    if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
                        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
                    }
                    var newData = [
                        func,
                        bitmask,
                        thisArg,
                        newPartials,
                        newHolders,
                        newPartialsRight,
                        newHoldersRight,
                        argPos,
                        ary2,
                        arity
                    ];
                    var result2 = wrapFunc.apply(undefined2, newData);
                    if (isLaziable(func)) {
                        setData(result2, newData);
                    }
                    result2.placeholder = placeholder;
                    return setWrapToString(result2, func, bitmask);
                }
                function createRound(methodName) {
                    var func = Math2[methodName];
                    return function(number, precision) {
                        number = toNumber(number);
                        precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
                        if (precision && nativeIsFinite(number)) {
                            var pair = (toString(number) + "e").split("e"), value1 = func(pair[0] + "e" + (+pair[1] + precision));
                            pair = (toString(value1) + "e").split("e");
                            return +(pair[0] + "e" + (+pair[1] - precision));
                        }
                        return func(number);
                    };
                }
                var createSet = !(Set2 && 1 / setToArray(new Set2([
                    ,
                    -0
                ]))[1] == INFINITY) ? noop : function(values2) {
                    return new Set2(values2);
                };
                function createToPairs(keysFunc) {
                    return function(object) {
                        var tag = getTag(object);
                        if (tag == mapTag) {
                            return mapToArray(object);
                        }
                        if (tag == setTag) {
                            return setToPairs(object);
                        }
                        return baseToPairs(object, keysFunc(object));
                    };
                }
                function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary2, arity) {
                    var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
                    if (!isBindKey && typeof func != "function") {
                        throw new TypeError2(FUNC_ERROR_TEXT);
                    }
                    var length = partials ? partials.length : 0;
                    if (!length) {
                        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
                        partials = holders = undefined2;
                    }
                    ary2 = ary2 === undefined2 ? ary2 : nativeMax(toInteger(ary2), 0);
                    arity = arity === undefined2 ? arity : toInteger(arity);
                    length -= holders ? holders.length : 0;
                    if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
                        var partialsRight = partials, holdersRight = holders;
                        partials = holders = undefined2;
                    }
                    var data = isBindKey ? undefined2 : getData(func);
                    var newData = [
                        func,
                        bitmask,
                        thisArg,
                        partials,
                        holders,
                        partialsRight,
                        holdersRight,
                        argPos,
                        ary2,
                        arity
                    ];
                    if (data) {
                        mergeData(newData, data);
                    }
                    func = newData[0];
                    bitmask = newData[1];
                    thisArg = newData[2];
                    partials = newData[3];
                    holders = newData[4];
                    arity = newData[9] = newData[9] === undefined2 ? isBindKey ? 0 : func.length : nativeMax(newData[9] - length, 0);
                    if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
                        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
                    }
                    if (!bitmask || bitmask == WRAP_BIND_FLAG) {
                        var result2 = createBind(func, bitmask, thisArg);
                    } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
                        result2 = createCurry(func, bitmask, arity);
                    } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
                        result2 = createPartial(func, bitmask, thisArg, partials);
                    } else {
                        result2 = createHybrid.apply(undefined2, newData);
                    }
                    var setter = data ? baseSetData : setData;
                    return setWrapToString(setter(result2, newData), func, bitmask);
                }
                function customDefaultsAssignIn(objValue, srcValue, key, object) {
                    if (objValue === undefined2 || eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key)) {
                        return srcValue;
                    }
                    return objValue;
                }
                function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
                    if (isObject(objValue) && isObject(srcValue)) {
                        stack.set(srcValue, objValue);
                        baseMerge(objValue, srcValue, undefined2, customDefaultsMerge, stack);
                        stack["delete"](srcValue);
                    }
                    return objValue;
                }
                function customOmitClone(value1) {
                    return isPlainObject(value1) ? undefined2 : value1;
                }
                function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
                    var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
                    if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
                        return false;
                    }
                    var arrStacked = stack.get(array);
                    var othStacked = stack.get(other);
                    if (arrStacked && othStacked) {
                        return arrStacked == other && othStacked == array;
                    }
                    var index = -1, result2 = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : undefined2;
                    stack.set(array, other);
                    stack.set(other, array);
                    while(++index < arrLength){
                        var arrValue = array[index], othValue = other[index];
                        if (customizer) {
                            var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
                        }
                        if (compared !== undefined2) {
                            if (compared) {
                                continue;
                            }
                            result2 = false;
                            break;
                        }
                        if (seen) {
                            if (!arraySome(other, function(othValue2, othIndex) {
                                if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
                                    return seen.push(othIndex);
                                }
                            })) {
                                result2 = false;
                                break;
                            }
                        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
                            result2 = false;
                            break;
                        }
                    }
                    stack["delete"](array);
                    stack["delete"](other);
                    return result2;
                }
                function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
                    switch(tag){
                        case dataViewTag:
                            if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
                                return false;
                            }
                            object = object.buffer;
                            other = other.buffer;
                        case arrayBufferTag:
                            if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
                                return false;
                            }
                            return true;
                        case boolTag2:
                        case dateTag:
                        case numberTag:
                            return eq(+object, +other);
                        case errorTag:
                            return object.name == other.name && object.message == other.message;
                        case regexpTag:
                        case stringTag:
                            return object == other + "";
                        case mapTag:
                            var convert = mapToArray;
                        case setTag:
                            var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
                            convert || (convert = setToArray);
                            if (object.size != other.size && !isPartial) {
                                return false;
                            }
                            var stacked = stack.get(object);
                            if (stacked) {
                                return stacked == other;
                            }
                            bitmask |= COMPARE_UNORDERED_FLAG;
                            stack.set(object, other);
                            var result2 = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
                            stack["delete"](object);
                            return result2;
                        case symbolTag:
                            if (symbolValueOf) {
                                return symbolValueOf.call(object) == symbolValueOf.call(other);
                            }
                    }
                    return false;
                }
                function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
                    var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
                    if (objLength != othLength && !isPartial) {
                        return false;
                    }
                    var index = objLength;
                    while(index--){
                        var key = objProps[index];
                        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
                            return false;
                        }
                    }
                    var objStacked = stack.get(object);
                    var othStacked = stack.get(other);
                    if (objStacked && othStacked) {
                        return objStacked == other && othStacked == object;
                    }
                    var result2 = true;
                    stack.set(object, other);
                    stack.set(other, object);
                    var skipCtor = isPartial;
                    while(++index < objLength){
                        key = objProps[index];
                        var objValue = object[key], othValue = other[key];
                        if (customizer) {
                            var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
                        }
                        if (!(compared === undefined2 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
                            result2 = false;
                            break;
                        }
                        skipCtor || (skipCtor = key == "constructor");
                    }
                    if (result2 && !skipCtor) {
                        var objCtor = object.constructor, othCtor = other.constructor;
                        if (objCtor != othCtor && "constructor" in object && "constructor" in other && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
                            result2 = false;
                        }
                    }
                    stack["delete"](object);
                    stack["delete"](other);
                    return result2;
                }
                function flatRest(func) {
                    return setToString(overRest(func, undefined2, flatten), func + "");
                }
                function getAllKeys(object) {
                    return baseGetAllKeys(object, keys, getSymbols);
                }
                function getAllKeysIn(object) {
                    return baseGetAllKeys(object, keysIn, getSymbolsIn);
                }
                var getData = !metaMap ? noop : function(func) {
                    return metaMap.get(func);
                };
                function getFuncName(func) {
                    var result2 = func.name + "", array = realNames[result2], length = hasOwnProperty.call(realNames, result2) ? array.length : 0;
                    while(length--){
                        var data = array[length], otherFunc = data.func;
                        if (otherFunc == null || otherFunc == func) {
                            return data.name;
                        }
                    }
                    return result2;
                }
                function getHolder(func) {
                    var object = hasOwnProperty.call(lodash, "placeholder") ? lodash : func;
                    return object.placeholder;
                }
                function getIteratee() {
                    var result2 = lodash.iteratee || iteratee;
                    result2 = result2 === iteratee ? baseIteratee : result2;
                    return arguments.length ? result2(arguments[0], arguments[1]) : result2;
                }
                function getMapData(map3, key) {
                    var data = map3.__data__;
                    return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
                }
                function getMatchData(object) {
                    var result2 = keys(object), length = result2.length;
                    while(length--){
                        var key = result2[length], value1 = object[key];
                        result2[length] = [
                            key,
                            value1,
                            isStrictComparable(value1)
                        ];
                    }
                    return result2;
                }
                function getNative(object, key) {
                    var value1 = getValue(object, key);
                    return baseIsNative(value1) ? value1 : undefined2;
                }
                function getRawTag(value1) {
                    var isOwn = hasOwnProperty.call(value1, symToStringTag), tag = value1[symToStringTag];
                    try {
                        value1[symToStringTag] = undefined2;
                        var unmasked = true;
                    } catch (e) {}
                    var result2 = nativeObjectToString.call(value1);
                    if (unmasked) {
                        if (isOwn) {
                            value1[symToStringTag] = tag;
                        } else {
                            delete value1[symToStringTag];
                        }
                    }
                    return result2;
                }
                var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
                    if (object == null) {
                        return [];
                    }
                    object = Object2(object);
                    return arrayFilter(nativeGetSymbols(object), function(symbol) {
                        return propertyIsEnumerable.call(object, symbol);
                    });
                };
                var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
                    var result2 = [];
                    while(object){
                        arrayPush(result2, getSymbols(object));
                        object = getPrototype(object);
                    }
                    return result2;
                };
                var getTag = baseGetTag;
                if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
                    getTag = function(value1) {
                        var result2 = baseGetTag(value1), Ctor = result2 == objectTag ? value1.constructor : undefined2, ctorString = Ctor ? toSource(Ctor) : "";
                        if (ctorString) {
                            switch(ctorString){
                                case dataViewCtorString:
                                    return dataViewTag;
                                case mapCtorString:
                                    return mapTag;
                                case promiseCtorString:
                                    return promiseTag;
                                case setCtorString:
                                    return setTag;
                                case weakMapCtorString:
                                    return weakMapTag;
                            }
                        }
                        return result2;
                    };
                }
                function getView(start, end, transforms) {
                    var index = -1, length = transforms.length;
                    while(++index < length){
                        var data = transforms[index], size2 = data.size;
                        switch(data.type){
                            case "drop":
                                start += size2;
                                break;
                            case "dropRight":
                                end -= size2;
                                break;
                            case "take":
                                end = nativeMin(end, start + size2);
                                break;
                            case "takeRight":
                                start = nativeMax(start, end - size2);
                                break;
                        }
                    }
                    return {
                        "start": start,
                        "end": end
                    };
                }
                function getWrapDetails(source) {
                    var match = source.match(reWrapDetails);
                    return match ? match[1].split(reSplitDetails) : [];
                }
                function hasPath(object, path5, hasFunc) {
                    path5 = castPath(path5, object);
                    var index = -1, length = path5.length, result2 = false;
                    while(++index < length){
                        var key = toKey(path5[index]);
                        if (!(result2 = object != null && hasFunc(object, key))) {
                            break;
                        }
                        object = object[key];
                    }
                    if (result2 || ++index != length) {
                        return result2;
                    }
                    length = object == null ? 0 : object.length;
                    return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
                }
                function initCloneArray(array) {
                    var length = array.length, result2 = new array.constructor(length);
                    if (length && typeof array[0] == "string" && hasOwnProperty.call(array, "index")) {
                        result2.index = array.index;
                        result2.input = array.input;
                    }
                    return result2;
                }
                function initCloneObject(object) {
                    return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
                }
                function initCloneByTag(object, tag, isDeep) {
                    var Ctor = object.constructor;
                    switch(tag){
                        case arrayBufferTag:
                            return cloneArrayBuffer(object);
                        case boolTag2:
                        case dateTag:
                            return new Ctor(+object);
                        case dataViewTag:
                            return cloneDataView(object, isDeep);
                        case float32Tag:
                        case float64Tag:
                        case int8Tag:
                        case int16Tag:
                        case int32Tag:
                        case uint8Tag:
                        case uint8ClampedTag:
                        case uint16Tag:
                        case uint32Tag:
                            return cloneTypedArray(object, isDeep);
                        case mapTag:
                            return new Ctor();
                        case numberTag:
                        case stringTag:
                            return new Ctor(object);
                        case regexpTag:
                            return cloneRegExp(object);
                        case setTag:
                            return new Ctor();
                        case symbolTag:
                            return cloneSymbol(object);
                    }
                }
                function insertWrapDetails(source, details) {
                    var length = details.length;
                    if (!length) {
                        return source;
                    }
                    var lastIndex = length - 1;
                    details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex];
                    details = details.join(length > 2 ? ", " : " ");
                    return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n");
                }
                function isFlattenable(value1) {
                    return isArray(value1) || isArguments(value1) || !!(spreadableSymbol && value1 && value1[spreadableSymbol]);
                }
                function isIndex(value1, length) {
                    var type = typeof value1;
                    length = length == null ? MAX_SAFE_INTEGER : length;
                    return !!length && (type == "number" || type != "symbol" && reIsUint.test(value1)) && value1 > -1 && value1 % 1 == 0 && value1 < length;
                }
                function isIterateeCall(value1, index, object) {
                    if (!isObject(object)) {
                        return false;
                    }
                    var type = typeof index;
                    if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
                        return eq(object[index], value1);
                    }
                    return false;
                }
                function isKey(value1, object) {
                    if (isArray(value1)) {
                        return false;
                    }
                    var type = typeof value1;
                    if (type == "number" || type == "symbol" || type == "boolean" || value1 == null || isSymbol(value1)) {
                        return true;
                    }
                    return reIsPlainProp.test(value1) || !reIsDeepProp.test(value1) || object != null && value1 in Object2(object);
                }
                function isKeyable(value1) {
                    var type = typeof value1;
                    return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value1 !== "__proto__" : value1 === null;
                }
                function isLaziable(func) {
                    var funcName = getFuncName(func), other = lodash[funcName];
                    if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) {
                        return false;
                    }
                    if (func === other) {
                        return true;
                    }
                    var data = getData(other);
                    return !!data && func === data[0];
                }
                function isMasked(func) {
                    return !!maskSrcKey && maskSrcKey in func;
                }
                var isMaskable = coreJsData ? isFunction : stubFalse;
                function isPrototype(value1) {
                    var Ctor = value1 && value1.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
                    return value1 === proto;
                }
                function isStrictComparable(value1) {
                    return value1 === value1 && !isObject(value1);
                }
                function matchesStrictComparable(key, srcValue) {
                    return function(object) {
                        if (object == null) {
                            return false;
                        }
                        return object[key] === srcValue && (srcValue !== undefined2 || key in Object2(object));
                    };
                }
                function memoizeCapped(func) {
                    var result2 = memoize(func, function(key) {
                        if (cache.size === MAX_MEMOIZE_SIZE) {
                            cache.clear();
                        }
                        return key;
                    });
                    var cache = result2.cache;
                    return result2;
                }
                function mergeData(data, source) {
                    var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
                    var isCombo = srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG || srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_REARG_FLAG && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG;
                    if (!(isCommon || isCombo)) {
                        return data;
                    }
                    if (srcBitmask & WRAP_BIND_FLAG) {
                        data[2] = source[2];
                        newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
                    }
                    var value1 = source[3];
                    if (value1) {
                        var partials = data[3];
                        data[3] = partials ? composeArgs(partials, value1, source[4]) : value1;
                        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
                    }
                    value1 = source[5];
                    if (value1) {
                        partials = data[5];
                        data[5] = partials ? composeArgsRight(partials, value1, source[6]) : value1;
                        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
                    }
                    value1 = source[7];
                    if (value1) {
                        data[7] = value1;
                    }
                    if (srcBitmask & WRAP_ARY_FLAG) {
                        data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
                    }
                    if (data[9] == null) {
                        data[9] = source[9];
                    }
                    data[0] = source[0];
                    data[1] = newBitmask;
                    return data;
                }
                function nativeKeysIn(object) {
                    var result2 = [];
                    if (object != null) {
                        for(var key in Object2(object)){
                            result2.push(key);
                        }
                    }
                    return result2;
                }
                function objectToString(value1) {
                    return nativeObjectToString.call(value1);
                }
                function overRest(func, start, transform2) {
                    start = nativeMax(start === undefined2 ? func.length - 1 : start, 0);
                    return function() {
                        var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array2(length);
                        while(++index < length){
                            array[index] = args[start + index];
                        }
                        index = -1;
                        var otherArgs = Array2(start + 1);
                        while(++index < start){
                            otherArgs[index] = args[index];
                        }
                        otherArgs[start] = transform2(array);
                        return apply(func, this, otherArgs);
                    };
                }
                function parent(object, path5) {
                    return path5.length < 2 ? object : baseGet(object, baseSlice(path5, 0, -1));
                }
                function reorder(array, indexes) {
                    var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array);
                    while(length--){
                        var index = indexes[length];
                        array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined2;
                    }
                    return array;
                }
                function safeGet(object, key) {
                    if (key === "constructor" && typeof object[key] === "function") {
                        return;
                    }
                    if (key == "__proto__") {
                        return;
                    }
                    return object[key];
                }
                var setData = shortOut(baseSetData);
                var setTimeout2 = ctxSetTimeout || function(func, wait) {
                    return root.setTimeout(func, wait);
                };
                var setToString = shortOut(baseSetToString);
                function setWrapToString(wrapper, reference, bitmask) {
                    var source = reference + "";
                    return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
                }
                function shortOut(func) {
                    var count = 0, lastCalled = 0;
                    return function() {
                        var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
                        lastCalled = stamp;
                        if (remaining > 0) {
                            if (++count >= HOT_COUNT) {
                                return arguments[0];
                            }
                        } else {
                            count = 0;
                        }
                        return func.apply(undefined2, arguments);
                    };
                }
                function shuffleSelf(array, size2) {
                    var index = -1, length = array.length, lastIndex = length - 1;
                    size2 = size2 === undefined2 ? length : size2;
                    while(++index < size2){
                        var rand = baseRandom(index, lastIndex), value1 = array[rand];
                        array[rand] = array[index];
                        array[index] = value1;
                    }
                    array.length = size2;
                    return array;
                }
                var stringToPath = memoizeCapped(function(string2) {
                    var result2 = [];
                    if (string2.charCodeAt(0) === 46) {
                        result2.push("");
                    }
                    string2.replace(rePropName, function(match, number, quote, subString) {
                        result2.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
                    });
                    return result2;
                });
                function toKey(value1) {
                    if (typeof value1 == "string" || isSymbol(value1)) {
                        return value1;
                    }
                    var result2 = value1 + "";
                    return result2 == "0" && 1 / value1 == -INFINITY ? "-0" : result2;
                }
                function toSource(func) {
                    if (func != null) {
                        try {
                            return funcToString.call(func);
                        } catch (e) {}
                        try {
                            return func + "";
                        } catch (e) {}
                    }
                    return "";
                }
                function updateWrapDetails(details, bitmask) {
                    arrayEach(wrapFlags, function(pair) {
                        var value1 = "_." + pair[0];
                        if (bitmask & pair[1] && !arrayIncludes(details, value1)) {
                            details.push(value1);
                        }
                    });
                    return details.sort();
                }
                function wrapperClone(wrapper) {
                    if (wrapper instanceof LazyWrapper) {
                        return wrapper.clone();
                    }
                    var result2 = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
                    result2.__actions__ = copyArray(wrapper.__actions__);
                    result2.__index__ = wrapper.__index__;
                    result2.__values__ = wrapper.__values__;
                    return result2;
                }
                function chunk(array, size2, guard) {
                    if (guard ? isIterateeCall(array, size2, guard) : size2 === undefined2) {
                        size2 = 1;
                    } else {
                        size2 = nativeMax(toInteger(size2), 0);
                    }
                    var length = array == null ? 0 : array.length;
                    if (!length || size2 < 1) {
                        return [];
                    }
                    var index = 0, resIndex = 0, result2 = Array2(nativeCeil(length / size2));
                    while(index < length){
                        result2[resIndex++] = baseSlice(array, index, index += size2);
                    }
                    return result2;
                }
                function compact(array) {
                    var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result2 = [];
                    while(++index < length){
                        var value1 = array[index];
                        if (value1) {
                            result2[resIndex++] = value1;
                        }
                    }
                    return result2;
                }
                function concat() {
                    var length = arguments.length;
                    if (!length) {
                        return [];
                    }
                    var args = Array2(length - 1), array = arguments[0], index = length;
                    while(index--){
                        args[index - 1] = arguments[index];
                    }
                    return arrayPush(isArray(array) ? copyArray(array) : [
                        array
                    ], baseFlatten(args, 1));
                }
                var difference = baseRest(function(array, values2) {
                    return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true)) : [];
                });
                var differenceBy = baseRest(function(array, values2) {
                    var iteratee2 = last(values2);
                    if (isArrayLikeObject(iteratee2)) {
                        iteratee2 = undefined2;
                    }
                    return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2)) : [];
                });
                var differenceWith = baseRest(function(array, values2) {
                    var comparator = last(values2);
                    if (isArrayLikeObject(comparator)) {
                        comparator = undefined2;
                    }
                    return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), undefined2, comparator) : [];
                });
                function drop(array, n, guard) {
                    var length = array == null ? 0 : array.length;
                    if (!length) {
                        return [];
                    }
                    n = guard || n === undefined2 ? 1 : toInteger(n);
                    return baseSlice(array, n < 0 ? 0 : n, length);
                }
                function dropRight(array, n, guard) {
                    var length = array == null ? 0 : array.length;
                    if (!length) {
                        return [];
                    }
                    n = guard || n === undefined2 ? 1 : toInteger(n);
                    n = length - n;
                    return baseSlice(array, 0, n < 0 ? 0 : n);
                }
                function dropRightWhile(array, predicate) {
                    return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true, true) : [];
                }
                function dropWhile(array, predicate) {
                    return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true) : [];
                }
                function fill(array, value1, start, end) {
                    var length = array == null ? 0 : array.length;
                    if (!length) {
                        return [];
                    }
                    if (start && typeof start != "number" && isIterateeCall(array, value1, start)) {
                        start = 0;
                        end = length;
                    }
                    return baseFill(array, value1, start, end);
                }
                function findIndex(array, predicate, fromIndex) {
                    var length = array == null ? 0 : array.length;
                    if (!length) {
                        return -1;
                    }
                    var index = fromIndex == null ? 0 : toInteger(fromIndex);
                    if (index < 0) {
                        index = nativeMax(length + index, 0);
                    }
                    return baseFindIndex(array, getIteratee(predicate, 3), index);
                }
                function findLastIndex(array, predicate, fromIndex) {
                    var length = array == null ? 0 : array.length;
                    if (!length) {
                        return -1;
                    }
                    var index = length - 1;
                    if (fromIndex !== undefined2) {
                        index = toInteger(fromIndex);
                        index = fromIndex < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
                    }
                    return baseFindIndex(array, getIteratee(predicate, 3), index, true);
                }
                function flatten(array) {
                    var length = array == null ? 0 : array.length;
                    return length ? baseFlatten(array, 1) : [];
                }
                function flattenDeep(array) {
                    var length = array == null ? 0 : array.length;
                    return length ? baseFlatten(array, INFINITY) : [];
                }
                function flattenDepth(array, depth) {
                    var length = array == null ? 0 : array.length;
                    if (!length) {
                        return [];
                    }
                    depth = depth === undefined2 ? 1 : toInteger(depth);
                    return baseFlatten(array, depth);
                }
                function fromPairs(pairs2) {
                    var index = -1, length = pairs2 == null ? 0 : pairs2.length, result2 = {};
                    while(++index < length){
                        var pair = pairs2[index];
                        result2[pair[0]] = pair[1];
                    }
                    return result2;
                }
                function head(array) {
                    return array && array.length ? array[0] : undefined2;
                }
                function indexOf2(array, value1, fromIndex) {
                    var length = array == null ? 0 : array.length;
                    if (!length) {
                        return -1;
                    }
                    var index = fromIndex == null ? 0 : toInteger(fromIndex);
                    if (index < 0) {
                        index = nativeMax(length + index, 0);
                    }
                    return baseIndexOf(array, value1, index);
                }
                function initial(array) {
                    var length = array == null ? 0 : array.length;
                    return length ? baseSlice(array, 0, -1) : [];
                }
                var intersection = baseRest(function(arrays) {
                    var mapped = arrayMap(arrays, castArrayLikeObject);
                    return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];
                });
                var intersectionBy = baseRest(function(arrays) {
                    var iteratee2 = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
                    if (iteratee2 === last(mapped)) {
                        iteratee2 = undefined2;
                    } else {
                        mapped.pop();
                    }
                    return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, getIteratee(iteratee2, 2)) : [];
                });
                var intersectionWith = baseRest(function(arrays) {
                    var comparator = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
                    comparator = typeof comparator == "function" ? comparator : undefined2;
                    if (comparator) {
                        mapped.pop();
                    }
                    return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
                });
                function join(array, separator) {
                    return array == null ? "" : nativeJoin.call(array, separator);
                }
                function last(array) {
                    var length = array == null ? 0 : array.length;
                    return length ? array[length - 1] : undefined2;
                }
                function lastIndexOf(array, value1, fromIndex) {
                    var length = array == null ? 0 : array.length;
                    if (!length) {
                        return -1;
                    }
                    var index = length;
                    if (fromIndex !== undefined2) {
                        index = toInteger(fromIndex);
                        index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
                    }
                    return value1 === value1 ? strictLastIndexOf(array, value1, index) : baseFindIndex(array, baseIsNaN, index, true);
                }
                function nth(array, n) {
                    return array && array.length ? baseNth(array, toInteger(n)) : undefined2;
                }
                var pull = baseRest(pullAll);
                function pullAll(array, values2) {
                    return array && array.length && values2 && values2.length ? basePullAll(array, values2) : array;
                }
                function pullAllBy(array, values2, iteratee2) {
                    return array && array.length && values2 && values2.length ? basePullAll(array, values2, getIteratee(iteratee2, 2)) : array;
                }
                function pullAllWith(array, values2, comparator) {
                    return array && array.length && values2 && values2.length ? basePullAll(array, values2, undefined2, comparator) : array;
                }
                var pullAt = flatRest(function(array, indexes) {
                    var length = array == null ? 0 : array.length, result2 = baseAt(array, indexes);
                    basePullAt(array, arrayMap(indexes, function(index) {
                        return isIndex(index, length) ? +index : index;
                    }).sort(compareAscending));
                    return result2;
                });
                function remove(array, predicate) {
                    var result2 = [];
                    if (!(array && array.length)) {
                        return result2;
                    }
                    var index = -1, indexes = [], length = array.length;
                    predicate = getIteratee(predicate, 3);
                    while(++index < length){
                        var value1 = array[index];
                        if (predicate(value1, index, array)) {
                            result2.push(value1);
                            indexes.push(index);
                        }
                    }
                    basePullAt(array, indexes);
                    return result2;
                }
                function reverse(array) {
                    return array == null ? array : nativeReverse.call(array);
                }
                function slice(array, start, end) {
                    var length = array == null ? 0 : array.length;
                    if (!length) {
                        return [];
                    }
                    if (end && typeof end != "number" && isIterateeCall(array, start, end)) {
                        start = 0;
                        end = length;
                    } else {
                        start = start == null ? 0 : toInteger(start);
                        end = end === undefined2 ? length : toInteger(end);
                    }
                    return baseSlice(array, start, end);
                }
                function sortedIndex(array, value1) {
                    return baseSortedIndex(array, value1);
                }
                function sortedIndexBy(array, value1, iteratee2) {
                    return baseSortedIndexBy(array, value1, getIteratee(iteratee2, 2));
                }
                function sortedIndexOf(array, value1) {
                    var length = array == null ? 0 : array.length;
                    if (length) {
                        var index = baseSortedIndex(array, value1);
                        if (index < length && eq(array[index], value1)) {
                            return index;
                        }
                    }
                    return -1;
                }
                function sortedLastIndex(array, value1) {
                    return baseSortedIndex(array, value1, true);
                }
                function sortedLastIndexBy(array, value1, iteratee2) {
                    return baseSortedIndexBy(array, value1, getIteratee(iteratee2, 2), true);
                }
                function sortedLastIndexOf(array, value1) {
                    var length = array == null ? 0 : array.length;
                    if (length) {
                        var index = baseSortedIndex(array, value1, true) - 1;
                        if (eq(array[index], value1)) {
                            return index;
                        }
                    }
                    return -1;
                }
                function sortedUniq(array) {
                    return array && array.length ? baseSortedUniq(array) : [];
                }
                function sortedUniqBy(array, iteratee2) {
                    return array && array.length ? baseSortedUniq(array, getIteratee(iteratee2, 2)) : [];
                }
                function tail(array) {
                    var length = array == null ? 0 : array.length;
                    return length ? baseSlice(array, 1, length) : [];
                }
                function take(array, n, guard) {
                    if (!(array && array.length)) {
                        return [];
                    }
                    n = guard || n === undefined2 ? 1 : toInteger(n);
                    return baseSlice(array, 0, n < 0 ? 0 : n);
                }
                function takeRight(array, n, guard) {
                    var length = array == null ? 0 : array.length;
                    if (!length) {
                        return [];
                    }
                    n = guard || n === undefined2 ? 1 : toInteger(n);
                    n = length - n;
                    return baseSlice(array, n < 0 ? 0 : n, length);
                }
                function takeRightWhile(array, predicate) {
                    return array && array.length ? baseWhile(array, getIteratee(predicate, 3), false, true) : [];
                }
                function takeWhile(array, predicate) {
                    return array && array.length ? baseWhile(array, getIteratee(predicate, 3)) : [];
                }
                var union = baseRest(function(arrays) {
                    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
                });
                var unionBy = baseRest(function(arrays) {
                    var iteratee2 = last(arrays);
                    if (isArrayLikeObject(iteratee2)) {
                        iteratee2 = undefined2;
                    }
                    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2));
                });
                var unionWith = baseRest(function(arrays) {
                    var comparator = last(arrays);
                    comparator = typeof comparator == "function" ? comparator : undefined2;
                    return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined2, comparator);
                });
                function uniq(array) {
                    return array && array.length ? baseUniq(array) : [];
                }
                function uniqBy(array, iteratee2) {
                    return array && array.length ? baseUniq(array, getIteratee(iteratee2, 2)) : [];
                }
                function uniqWith(array, comparator) {
                    comparator = typeof comparator == "function" ? comparator : undefined2;
                    return array && array.length ? baseUniq(array, undefined2, comparator) : [];
                }
                function unzip(array) {
                    if (!(array && array.length)) {
                        return [];
                    }
                    var length = 0;
                    array = arrayFilter(array, function(group) {
                        if (isArrayLikeObject(group)) {
                            length = nativeMax(group.length, length);
                            return true;
                        }
                    });
                    return baseTimes(length, function(index) {
                        return arrayMap(array, baseProperty(index));
                    });
                }
                function unzipWith(array, iteratee2) {
                    if (!(array && array.length)) {
                        return [];
                    }
                    var result2 = unzip(array);
                    if (iteratee2 == null) {
                        return result2;
                    }
                    return arrayMap(result2, function(group) {
                        return apply(iteratee2, undefined2, group);
                    });
                }
                var without = baseRest(function(array, values2) {
                    return isArrayLikeObject(array) ? baseDifference(array, values2) : [];
                });
                var xor = baseRest(function(arrays) {
                    return baseXor(arrayFilter(arrays, isArrayLikeObject));
                });
                var xorBy = baseRest(function(arrays) {
                    var iteratee2 = last(arrays);
                    if (isArrayLikeObject(iteratee2)) {
                        iteratee2 = undefined2;
                    }
                    return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee2, 2));
                });
                var xorWith = baseRest(function(arrays) {
                    var comparator = last(arrays);
                    comparator = typeof comparator == "function" ? comparator : undefined2;
                    return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined2, comparator);
                });
                var zip = baseRest(unzip);
                function zipObject(props, values2) {
                    return baseZipObject(props || [], values2 || [], assignValue);
                }
                function zipObjectDeep(props, values2) {
                    return baseZipObject(props || [], values2 || [], baseSet);
                }
                var zipWith = baseRest(function(arrays) {
                    var length = arrays.length, iteratee2 = length > 1 ? arrays[length - 1] : undefined2;
                    iteratee2 = typeof iteratee2 == "function" ? (arrays.pop(), iteratee2) : undefined2;
                    return unzipWith(arrays, iteratee2);
                });
                function chain(value1) {
                    var result2 = lodash(value1);
                    result2.__chain__ = true;
                    return result2;
                }
                function tap(value1, interceptor) {
                    interceptor(value1);
                    return value1;
                }
                function thru(value1, interceptor) {
                    return interceptor(value1);
                }
                var wrapperAt = flatRest(function(paths) {
                    var length = paths.length, start = length ? paths[0] : 0, value1 = this.__wrapped__, interceptor = function(object) {
                        return baseAt(object, paths);
                    };
                    if (length > 1 || this.__actions__.length || !(value1 instanceof LazyWrapper) || !isIndex(start)) {
                        return this.thru(interceptor);
                    }
                    value1 = value1.slice(start, +start + (length ? 1 : 0));
                    value1.__actions__.push({
                        "func": thru,
                        "args": [
                            interceptor
                        ],
                        "thisArg": undefined2
                    });
                    return new LodashWrapper(value1, this.__chain__).thru(function(array) {
                        if (length && !array.length) {
                            array.push(undefined2);
                        }
                        return array;
                    });
                });
                function wrapperChain() {
                    return chain(this);
                }
                function wrapperCommit() {
                    return new LodashWrapper(this.value(), this.__chain__);
                }
                function wrapperNext() {
                    if (this.__values__ === undefined2) {
                        this.__values__ = toArray(this.value());
                    }
                    var done = this.__index__ >= this.__values__.length, value1 = done ? undefined2 : this.__values__[this.__index__++];
                    return {
                        "done": done,
                        "value": value1
                    };
                }
                function wrapperToIterator() {
                    return this;
                }
                function wrapperPlant(value1) {
                    var result2, parent2 = this;
                    while(parent2 instanceof baseLodash){
                        var clone2 = wrapperClone(parent2);
                        clone2.__index__ = 0;
                        clone2.__values__ = undefined2;
                        if (result2) {
                            previous.__wrapped__ = clone2;
                        } else {
                            result2 = clone2;
                        }
                        var previous = clone2;
                        parent2 = parent2.__wrapped__;
                    }
                    previous.__wrapped__ = value1;
                    return result2;
                }
                function wrapperReverse() {
                    var value1 = this.__wrapped__;
                    if (value1 instanceof LazyWrapper) {
                        var wrapped = value1;
                        if (this.__actions__.length) {
                            wrapped = new LazyWrapper(this);
                        }
                        wrapped = wrapped.reverse();
                        wrapped.__actions__.push({
                            "func": thru,
                            "args": [
                                reverse
                            ],
                            "thisArg": undefined2
                        });
                        return new LodashWrapper(wrapped, this.__chain__);
                    }
                    return this.thru(reverse);
                }
                function wrapperValue() {
                    return baseWrapperValue(this.__wrapped__, this.__actions__);
                }
                var countBy = createAggregator(function(result2, value1, key) {
                    if (hasOwnProperty.call(result2, key)) {
                        ++result2[key];
                    } else {
                        baseAssignValue(result2, key, 1);
                    }
                });
                function every(collection, predicate, guard) {
                    var func = isArray(collection) ? arrayEvery : baseEvery;
                    if (guard && isIterateeCall(collection, predicate, guard)) {
                        predicate = undefined2;
                    }
                    return func(collection, getIteratee(predicate, 3));
                }
                function filter(collection, predicate) {
                    var func = isArray(collection) ? arrayFilter : baseFilter;
                    return func(collection, getIteratee(predicate, 3));
                }
                var find = createFind(findIndex);
                var findLast = createFind(findLastIndex);
                function flatMap(collection, iteratee2) {
                    return baseFlatten(map2(collection, iteratee2), 1);
                }
                function flatMapDeep(collection, iteratee2) {
                    return baseFlatten(map2(collection, iteratee2), INFINITY);
                }
                function flatMapDepth(collection, iteratee2, depth) {
                    depth = depth === undefined2 ? 1 : toInteger(depth);
                    return baseFlatten(map2(collection, iteratee2), depth);
                }
                function forEach(collection, iteratee2) {
                    var func = isArray(collection) ? arrayEach : baseEach;
                    return func(collection, getIteratee(iteratee2, 3));
                }
                function forEachRight(collection, iteratee2) {
                    var func = isArray(collection) ? arrayEachRight : baseEachRight;
                    return func(collection, getIteratee(iteratee2, 3));
                }
                var groupBy = createAggregator(function(result2, value1, key) {
                    if (hasOwnProperty.call(result2, key)) {
                        result2[key].push(value1);
                    } else {
                        baseAssignValue(result2, key, [
                            value1
                        ]);
                    }
                });
                function includes(collection, value1, fromIndex, guard) {
                    collection = isArrayLike(collection) ? collection : values(collection);
                    fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;
                    var length = collection.length;
                    if (fromIndex < 0) {
                        fromIndex = nativeMax(length + fromIndex, 0);
                    }
                    return isString3(collection) ? fromIndex <= length && collection.indexOf(value1, fromIndex) > -1 : !!length && baseIndexOf(collection, value1, fromIndex) > -1;
                }
                var invokeMap = baseRest(function(collection, path5, args) {
                    var index = -1, isFunc = typeof path5 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
                    baseEach(collection, function(value1) {
                        result2[++index] = isFunc ? apply(path5, value1, args) : baseInvoke(value1, path5, args);
                    });
                    return result2;
                });
                var keyBy = createAggregator(function(result2, value1, key) {
                    baseAssignValue(result2, key, value1);
                });
                function map2(collection, iteratee2) {
                    var func = isArray(collection) ? arrayMap : baseMap;
                    return func(collection, getIteratee(iteratee2, 3));
                }
                function orderBy(collection, iteratees, orders, guard) {
                    if (collection == null) {
                        return [];
                    }
                    if (!isArray(iteratees)) {
                        iteratees = iteratees == null ? [] : [
                            iteratees
                        ];
                    }
                    orders = guard ? undefined2 : orders;
                    if (!isArray(orders)) {
                        orders = orders == null ? [] : [
                            orders
                        ];
                    }
                    return baseOrderBy(collection, iteratees, orders);
                }
                var partition = createAggregator(function(result2, value1, key) {
                    result2[key ? 0 : 1].push(value1);
                }, function() {
                    return [
                        [],
                        []
                    ];
                });
                function reduce(collection, iteratee2, accumulator) {
                    var func = isArray(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3;
                    return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEach);
                }
                function reduceRight(collection, iteratee2, accumulator) {
                    var func = isArray(collection) ? arrayReduceRight : baseReduce, initAccum = arguments.length < 3;
                    return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEachRight);
                }
                function reject(collection, predicate) {
                    var func = isArray(collection) ? arrayFilter : baseFilter;
                    return func(collection, negate(getIteratee(predicate, 3)));
                }
                function sample(collection) {
                    var func = isArray(collection) ? arraySample : baseSample;
                    return func(collection);
                }
                function sampleSize(collection, n, guard) {
                    if (guard ? isIterateeCall(collection, n, guard) : n === undefined2) {
                        n = 1;
                    } else {
                        n = toInteger(n);
                    }
                    var func = isArray(collection) ? arraySampleSize : baseSampleSize;
                    return func(collection, n);
                }
                function shuffle(collection) {
                    var func = isArray(collection) ? arrayShuffle : baseShuffle;
                    return func(collection);
                }
                function size(collection) {
                    if (collection == null) {
                        return 0;
                    }
                    if (isArrayLike(collection)) {
                        return isString3(collection) ? stringSize(collection) : collection.length;
                    }
                    var tag = getTag(collection);
                    if (tag == mapTag || tag == setTag) {
                        return collection.size;
                    }
                    return baseKeys(collection).length;
                }
                function some(collection, predicate, guard) {
                    var func = isArray(collection) ? arraySome : baseSome;
                    if (guard && isIterateeCall(collection, predicate, guard)) {
                        predicate = undefined2;
                    }
                    return func(collection, getIteratee(predicate, 3));
                }
                var sortBy = baseRest(function(collection, iteratees) {
                    if (collection == null) {
                        return [];
                    }
                    var length = iteratees.length;
                    if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
                        iteratees = [];
                    } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
                        iteratees = [
                            iteratees[0]
                        ];
                    }
                    return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
                });
                var now = ctxNow || function() {
                    return root.Date.now();
                };
                function after(n, func) {
                    if (typeof func != "function") {
                        throw new TypeError2(FUNC_ERROR_TEXT);
                    }
                    n = toInteger(n);
                    return function() {
                        if (--n < 1) {
                            return func.apply(this, arguments);
                        }
                    };
                }
                function ary(func, n, guard) {
                    n = guard ? undefined2 : n;
                    n = func && n == null ? func.length : n;
                    return createWrap(func, WRAP_ARY_FLAG, undefined2, undefined2, undefined2, undefined2, n);
                }
                function before(n, func) {
                    var result2;
                    if (typeof func != "function") {
                        throw new TypeError2(FUNC_ERROR_TEXT);
                    }
                    n = toInteger(n);
                    return function() {
                        if (--n > 0) {
                            result2 = func.apply(this, arguments);
                        }
                        if (n <= 1) {
                            func = undefined2;
                        }
                        return result2;
                    };
                }
                var bind = baseRest(function(func, thisArg, partials) {
                    var bitmask = WRAP_BIND_FLAG;
                    if (partials.length) {
                        var holders = replaceHolders(partials, getHolder(bind));
                        bitmask |= WRAP_PARTIAL_FLAG;
                    }
                    return createWrap(func, bitmask, thisArg, partials, holders);
                });
                var bindKey = baseRest(function(object, key, partials) {
                    var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
                    if (partials.length) {
                        var holders = replaceHolders(partials, getHolder(bindKey));
                        bitmask |= WRAP_PARTIAL_FLAG;
                    }
                    return createWrap(key, bitmask, object, partials, holders);
                });
                function curry(func, arity, guard) {
                    arity = guard ? undefined2 : arity;
                    var result2 = createWrap(func, WRAP_CURRY_FLAG, undefined2, undefined2, undefined2, undefined2, undefined2, arity);
                    result2.placeholder = curry.placeholder;
                    return result2;
                }
                function curryRight(func, arity, guard) {
                    arity = guard ? undefined2 : arity;
                    var result2 = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined2, undefined2, undefined2, undefined2, undefined2, arity);
                    result2.placeholder = curryRight.placeholder;
                    return result2;
                }
                function debounce(func, wait, options) {
                    var lastArgs, lastThis, maxWait, result2, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
                    if (typeof func != "function") {
                        throw new TypeError2(FUNC_ERROR_TEXT);
                    }
                    wait = toNumber(wait) || 0;
                    if (isObject(options)) {
                        leading = !!options.leading;
                        maxing = "maxWait" in options;
                        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
                        trailing = "trailing" in options ? !!options.trailing : trailing;
                    }
                    function invokeFunc(time) {
                        var args = lastArgs, thisArg = lastThis;
                        lastArgs = lastThis = undefined2;
                        lastInvokeTime = time;
                        result2 = func.apply(thisArg, args);
                        return result2;
                    }
                    function leadingEdge(time) {
                        lastInvokeTime = time;
                        timerId = setTimeout2(timerExpired, wait);
                        return leading ? invokeFunc(time) : result2;
                    }
                    function remainingWait(time) {
                        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
                        return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
                    }
                    function shouldInvoke(time) {
                        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
                        return lastCallTime === undefined2 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
                    }
                    function timerExpired() {
                        var time = now();
                        if (shouldInvoke(time)) {
                            return trailingEdge(time);
                        }
                        timerId = setTimeout2(timerExpired, remainingWait(time));
                    }
                    function trailingEdge(time) {
                        timerId = undefined2;
                        if (trailing && lastArgs) {
                            return invokeFunc(time);
                        }
                        lastArgs = lastThis = undefined2;
                        return result2;
                    }
                    function cancel() {
                        if (timerId !== undefined2) {
                            clearTimeout2(timerId);
                        }
                        lastInvokeTime = 0;
                        lastArgs = lastCallTime = lastThis = timerId = undefined2;
                    }
                    function flush() {
                        return timerId === undefined2 ? result2 : trailingEdge(now());
                    }
                    function debounced() {
                        var time = now(), isInvoking = shouldInvoke(time);
                        lastArgs = arguments;
                        lastThis = this;
                        lastCallTime = time;
                        if (isInvoking) {
                            if (timerId === undefined2) {
                                return leadingEdge(lastCallTime);
                            }
                            if (maxing) {
                                clearTimeout2(timerId);
                                timerId = setTimeout2(timerExpired, wait);
                                return invokeFunc(lastCallTime);
                            }
                        }
                        if (timerId === undefined2) {
                            timerId = setTimeout2(timerExpired, wait);
                        }
                        return result2;
                    }
                    debounced.cancel = cancel;
                    debounced.flush = flush;
                    return debounced;
                }
                var defer = baseRest(function(func, args) {
                    return baseDelay(func, 1, args);
                });
                var delay = baseRest(function(func, wait, args) {
                    return baseDelay(func, toNumber(wait) || 0, args);
                });
                function flip(func) {
                    return createWrap(func, WRAP_FLIP_FLAG);
                }
                function memoize(func, resolver) {
                    if (typeof func != "function" || resolver != null && typeof resolver != "function") {
                        throw new TypeError2(FUNC_ERROR_TEXT);
                    }
                    var memoized = function() {
                        var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
                        if (cache.has(key)) {
                            return cache.get(key);
                        }
                        var result2 = func.apply(this, args);
                        memoized.cache = cache.set(key, result2) || cache;
                        return result2;
                    };
                    memoized.cache = new (memoize.Cache || MapCache)();
                    return memoized;
                }
                memoize.Cache = MapCache;
                function negate(predicate) {
                    if (typeof predicate != "function") {
                        throw new TypeError2(FUNC_ERROR_TEXT);
                    }
                    return function() {
                        var args = arguments;
                        switch(args.length){
                            case 0:
                                return !predicate.call(this);
                            case 1:
                                return !predicate.call(this, args[0]);
                            case 2:
                                return !predicate.call(this, args[0], args[1]);
                            case 3:
                                return !predicate.call(this, args[0], args[1], args[2]);
                        }
                        return !predicate.apply(this, args);
                    };
                }
                function once(func) {
                    return before(2, func);
                }
                var overArgs = castRest(function(func, transforms) {
                    transforms = transforms.length == 1 && isArray(transforms[0]) ? arrayMap(transforms[0], baseUnary(getIteratee())) : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));
                    var funcsLength = transforms.length;
                    return baseRest(function(args) {
                        var index = -1, length = nativeMin(args.length, funcsLength);
                        while(++index < length){
                            args[index] = transforms[index].call(this, args[index]);
                        }
                        return apply(func, this, args);
                    });
                });
                var partial = baseRest(function(func, partials) {
                    var holders = replaceHolders(partials, getHolder(partial));
                    return createWrap(func, WRAP_PARTIAL_FLAG, undefined2, partials, holders);
                });
                var partialRight = baseRest(function(func, partials) {
                    var holders = replaceHolders(partials, getHolder(partialRight));
                    return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined2, partials, holders);
                });
                var rearg = flatRest(function(func, indexes) {
                    return createWrap(func, WRAP_REARG_FLAG, undefined2, undefined2, undefined2, indexes);
                });
                function rest(func, start) {
                    if (typeof func != "function") {
                        throw new TypeError2(FUNC_ERROR_TEXT);
                    }
                    start = start === undefined2 ? start : toInteger(start);
                    return baseRest(func, start);
                }
                function spread(func, start) {
                    if (typeof func != "function") {
                        throw new TypeError2(FUNC_ERROR_TEXT);
                    }
                    start = start == null ? 0 : nativeMax(toInteger(start), 0);
                    return baseRest(function(args) {
                        var array = args[start], otherArgs = castSlice(args, 0, start);
                        if (array) {
                            arrayPush(otherArgs, array);
                        }
                        return apply(func, this, otherArgs);
                    });
                }
                function throttle(func, wait, options) {
                    var leading = true, trailing = true;
                    if (typeof func != "function") {
                        throw new TypeError2(FUNC_ERROR_TEXT);
                    }
                    if (isObject(options)) {
                        leading = "leading" in options ? !!options.leading : leading;
                        trailing = "trailing" in options ? !!options.trailing : trailing;
                    }
                    return debounce(func, wait, {
                        "leading": leading,
                        "maxWait": wait,
                        "trailing": trailing
                    });
                }
                function unary(func) {
                    return ary(func, 1);
                }
                function wrap(value1, wrapper) {
                    return partial(castFunction(wrapper), value1);
                }
                function castArray() {
                    if (!arguments.length) {
                        return [];
                    }
                    var value1 = arguments[0];
                    return isArray(value1) ? value1 : [
                        value1
                    ];
                }
                function clone(value1) {
                    return baseClone(value1, CLONE_SYMBOLS_FLAG);
                }
                function cloneWith(value1, customizer) {
                    customizer = typeof customizer == "function" ? customizer : undefined2;
                    return baseClone(value1, CLONE_SYMBOLS_FLAG, customizer);
                }
                function cloneDeep2(value1) {
                    return baseClone(value1, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
                }
                function cloneDeepWith(value1, customizer) {
                    customizer = typeof customizer == "function" ? customizer : undefined2;
                    return baseClone(value1, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
                }
                function conformsTo(object, source) {
                    return source == null || baseConformsTo(object, source, keys(source));
                }
                function eq(value1, other) {
                    return value1 === other || value1 !== value1 && other !== other;
                }
                var gt = createRelationalOperation(baseGt);
                var gte = createRelationalOperation(function(value1, other) {
                    return value1 >= other;
                });
                var isArguments = baseIsArguments(/* @__PURE__ */ function() {
                    return arguments;
                }()) ? baseIsArguments : function(value1) {
                    return isObjectLike(value1) && hasOwnProperty.call(value1, "callee") && !propertyIsEnumerable.call(value1, "callee");
                };
                var isArray = Array2.isArray;
                var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;
                function isArrayLike(value1) {
                    return value1 != null && isLength(value1.length) && !isFunction(value1);
                }
                function isArrayLikeObject(value1) {
                    return isObjectLike(value1) && isArrayLike(value1);
                }
                function isBoolean3(value1) {
                    return value1 === true || value1 === false || isObjectLike(value1) && baseGetTag(value1) == boolTag2;
                }
                var isBuffer = nativeIsBuffer || stubFalse;
                var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
                function isElement(value1) {
                    return isObjectLike(value1) && value1.nodeType === 1 && !isPlainObject(value1);
                }
                function isEmpty2(value1) {
                    if (value1 == null) {
                        return true;
                    }
                    if (isArrayLike(value1) && (isArray(value1) || typeof value1 == "string" || typeof value1.splice == "function" || isBuffer(value1) || isTypedArray(value1) || isArguments(value1))) {
                        return !value1.length;
                    }
                    var tag = getTag(value1);
                    if (tag == mapTag || tag == setTag) {
                        return !value1.size;
                    }
                    if (isPrototype(value1)) {
                        return !baseKeys(value1).length;
                    }
                    for(var key in value1){
                        if (hasOwnProperty.call(value1, key)) {
                            return false;
                        }
                    }
                    return true;
                }
                function isEqual(value1, other) {
                    return baseIsEqual(value1, other);
                }
                function isEqualWith(value1, other, customizer) {
                    customizer = typeof customizer == "function" ? customizer : undefined2;
                    var result2 = customizer ? customizer(value1, other) : undefined2;
                    return result2 === undefined2 ? baseIsEqual(value1, other, undefined2, customizer) : !!result2;
                }
                function isError(value1) {
                    if (!isObjectLike(value1)) {
                        return false;
                    }
                    var tag = baseGetTag(value1);
                    return tag == errorTag || tag == domExcTag || typeof value1.message == "string" && typeof value1.name == "string" && !isPlainObject(value1);
                }
                function isFinite2(value1) {
                    return typeof value1 == "number" && nativeIsFinite(value1);
                }
                function isFunction(value1) {
                    if (!isObject(value1)) {
                        return false;
                    }
                    var tag = baseGetTag(value1);
                    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
                }
                function isInteger(value1) {
                    return typeof value1 == "number" && value1 == toInteger(value1);
                }
                function isLength(value1) {
                    return typeof value1 == "number" && value1 > -1 && value1 % 1 == 0 && value1 <= MAX_SAFE_INTEGER;
                }
                function isObject(value1) {
                    var type = typeof value1;
                    return value1 != null && (type == "object" || type == "function");
                }
                function isObjectLike(value1) {
                    return value1 != null && typeof value1 == "object";
                }
                var isMap2 = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
                function isMatch(object, source) {
                    return object === source || baseIsMatch(object, source, getMatchData(source));
                }
                function isMatchWith(object, source, customizer) {
                    customizer = typeof customizer == "function" ? customizer : undefined2;
                    return baseIsMatch(object, source, getMatchData(source), customizer);
                }
                function isNaN2(value1) {
                    return isNumber3(value1) && value1 != +value1;
                }
                function isNative(value1) {
                    if (isMaskable(value1)) {
                        throw new Error2(CORE_ERROR_TEXT);
                    }
                    return baseIsNative(value1);
                }
                function isNull(value1) {
                    return value1 === null;
                }
                function isNil(value1) {
                    return value1 == null;
                }
                function isNumber3(value1) {
                    return typeof value1 == "number" || isObjectLike(value1) && baseGetTag(value1) == numberTag;
                }
                function isPlainObject(value1) {
                    if (!isObjectLike(value1) || baseGetTag(value1) != objectTag) {
                        return false;
                    }
                    var proto = getPrototype(value1);
                    if (proto === null) {
                        return true;
                    }
                    var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
                    return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
                }
                var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
                function isSafeInteger(value1) {
                    return isInteger(value1) && value1 >= -MAX_SAFE_INTEGER && value1 <= MAX_SAFE_INTEGER;
                }
                var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
                function isString3(value1) {
                    return typeof value1 == "string" || !isArray(value1) && isObjectLike(value1) && baseGetTag(value1) == stringTag;
                }
                function isSymbol(value1) {
                    return typeof value1 == "symbol" || isObjectLike(value1) && baseGetTag(value1) == symbolTag;
                }
                var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
                function isUndefined(value1) {
                    return value1 === undefined2;
                }
                function isWeakMap(value1) {
                    return isObjectLike(value1) && getTag(value1) == weakMapTag;
                }
                function isWeakSet(value1) {
                    return isObjectLike(value1) && baseGetTag(value1) == weakSetTag;
                }
                var lt = createRelationalOperation(baseLt);
                var lte = createRelationalOperation(function(value1, other) {
                    return value1 <= other;
                });
                function toArray(value1) {
                    if (!value1) {
                        return [];
                    }
                    if (isArrayLike(value1)) {
                        return isString3(value1) ? stringToArray(value1) : copyArray(value1);
                    }
                    if (symIterator && value1[symIterator]) {
                        return iteratorToArray(value1[symIterator]());
                    }
                    var tag = getTag(value1), func = tag == mapTag ? mapToArray : tag == setTag ? setToArray : values;
                    return func(value1);
                }
                function toFinite(value1) {
                    if (!value1) {
                        return value1 === 0 ? value1 : 0;
                    }
                    value1 = toNumber(value1);
                    if (value1 === INFINITY || value1 === -INFINITY) {
                        var sign = value1 < 0 ? -1 : 1;
                        return sign * MAX_INTEGER;
                    }
                    return value1 === value1 ? value1 : 0;
                }
                function toInteger(value1) {
                    var result2 = toFinite(value1), remainder = result2 % 1;
                    return result2 === result2 ? remainder ? result2 - remainder : result2 : 0;
                }
                function toLength(value1) {
                    return value1 ? baseClamp(toInteger(value1), 0, MAX_ARRAY_LENGTH) : 0;
                }
                function toNumber(value1) {
                    if (typeof value1 == "number") {
                        return value1;
                    }
                    if (isSymbol(value1)) {
                        return NAN;
                    }
                    if (isObject(value1)) {
                        var other = typeof value1.valueOf == "function" ? value1.valueOf() : value1;
                        value1 = isObject(other) ? other + "" : other;
                    }
                    if (typeof value1 != "string") {
                        return value1 === 0 ? value1 : +value1;
                    }
                    value1 = baseTrim(value1);
                    var isBinary = reIsBinary.test(value1);
                    return isBinary || reIsOctal.test(value1) ? freeParseInt(value1.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value1) ? NAN : +value1;
                }
                function toPlainObject(value1) {
                    return copyObject(value1, keysIn(value1));
                }
                function toSafeInteger(value1) {
                    return value1 ? baseClamp(toInteger(value1), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) : value1 === 0 ? value1 : 0;
                }
                function toString(value1) {
                    return value1 == null ? "" : baseToString(value1);
                }
                var assign = createAssigner(function(object, source) {
                    if (isPrototype(source) || isArrayLike(source)) {
                        copyObject(source, keys(source), object);
                        return;
                    }
                    for(var key in source){
                        if (hasOwnProperty.call(source, key)) {
                            assignValue(object, key, source[key]);
                        }
                    }
                });
                var assignIn = createAssigner(function(object, source) {
                    copyObject(source, keysIn(source), object);
                });
                var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
                    copyObject(source, keysIn(source), object, customizer);
                });
                var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
                    copyObject(source, keys(source), object, customizer);
                });
                var at = flatRest(baseAt);
                function create(prototype, properties) {
                    var result2 = baseCreate(prototype);
                    return properties == null ? result2 : baseAssign(result2, properties);
                }
                var defaults = baseRest(function(object, sources) {
                    object = Object2(object);
                    var index = -1;
                    var length = sources.length;
                    var guard = length > 2 ? sources[2] : undefined2;
                    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
                        length = 1;
                    }
                    while(++index < length){
                        var source = sources[index];
                        var props = keysIn(source);
                        var propsIndex = -1;
                        var propsLength = props.length;
                        while(++propsIndex < propsLength){
                            var key = props[propsIndex];
                            var value1 = object[key];
                            if (value1 === undefined2 || eq(value1, objectProto[key]) && !hasOwnProperty.call(object, key)) {
                                object[key] = source[key];
                            }
                        }
                    }
                    return object;
                });
                var defaultsDeep = baseRest(function(args) {
                    args.push(undefined2, customDefaultsMerge);
                    return apply(mergeWith, undefined2, args);
                });
                function findKey(object, predicate) {
                    return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
                }
                function findLastKey(object, predicate) {
                    return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
                }
                function forIn(object, iteratee2) {
                    return object == null ? object : baseFor(object, getIteratee(iteratee2, 3), keysIn);
                }
                function forInRight(object, iteratee2) {
                    return object == null ? object : baseForRight(object, getIteratee(iteratee2, 3), keysIn);
                }
                function forOwn(object, iteratee2) {
                    return object && baseForOwn(object, getIteratee(iteratee2, 3));
                }
                function forOwnRight(object, iteratee2) {
                    return object && baseForOwnRight(object, getIteratee(iteratee2, 3));
                }
                function functions(object) {
                    return object == null ? [] : baseFunctions(object, keys(object));
                }
                function functionsIn(object) {
                    return object == null ? [] : baseFunctions(object, keysIn(object));
                }
                function get(object, path5, defaultValue) {
                    var result2 = object == null ? undefined2 : baseGet(object, path5);
                    return result2 === undefined2 ? defaultValue : result2;
                }
                function has(object, path5) {
                    return object != null && hasPath(object, path5, baseHas);
                }
                function hasIn(object, path5) {
                    return object != null && hasPath(object, path5, baseHasIn);
                }
                var invert = createInverter(function(result2, value1, key) {
                    if (value1 != null && typeof value1.toString != "function") {
                        value1 = nativeObjectToString.call(value1);
                    }
                    result2[value1] = key;
                }, constant(identity));
                var invertBy = createInverter(function(result2, value1, key) {
                    if (value1 != null && typeof value1.toString != "function") {
                        value1 = nativeObjectToString.call(value1);
                    }
                    if (hasOwnProperty.call(result2, value1)) {
                        result2[value1].push(key);
                    } else {
                        result2[value1] = [
                            key
                        ];
                    }
                }, getIteratee);
                var invoke = baseRest(baseInvoke);
                function keys(object) {
                    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
                }
                function keysIn(object) {
                    return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
                }
                function mapKeys(object, iteratee2) {
                    var result2 = {};
                    iteratee2 = getIteratee(iteratee2, 3);
                    baseForOwn(object, function(value1, key, object2) {
                        baseAssignValue(result2, iteratee2(value1, key, object2), value1);
                    });
                    return result2;
                }
                function mapValues(object, iteratee2) {
                    var result2 = {};
                    iteratee2 = getIteratee(iteratee2, 3);
                    baseForOwn(object, function(value1, key, object2) {
                        baseAssignValue(result2, key, iteratee2(value1, key, object2));
                    });
                    return result2;
                }
                var merge = createAssigner(function(object, source, srcIndex) {
                    baseMerge(object, source, srcIndex);
                });
                var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
                    baseMerge(object, source, srcIndex, customizer);
                });
                var omit = flatRest(function(object, paths) {
                    var result2 = {};
                    if (object == null) {
                        return result2;
                    }
                    var isDeep = false;
                    paths = arrayMap(paths, function(path5) {
                        path5 = castPath(path5, object);
                        isDeep || (isDeep = path5.length > 1);
                        return path5;
                    });
                    copyObject(object, getAllKeysIn(object), result2);
                    if (isDeep) {
                        result2 = baseClone(result2, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
                    }
                    var length = paths.length;
                    while(length--){
                        baseUnset(result2, paths[length]);
                    }
                    return result2;
                });
                function omitBy(object, predicate) {
                    return pickBy(object, negate(getIteratee(predicate)));
                }
                var pick = flatRest(function(object, paths) {
                    return object == null ? {} : basePick(object, paths);
                });
                function pickBy(object, predicate) {
                    if (object == null) {
                        return {};
                    }
                    var props = arrayMap(getAllKeysIn(object), function(prop) {
                        return [
                            prop
                        ];
                    });
                    predicate = getIteratee(predicate);
                    return basePickBy(object, props, function(value1, path5) {
                        return predicate(value1, path5[0]);
                    });
                }
                function result(object, path5, defaultValue) {
                    path5 = castPath(path5, object);
                    var index = -1, length = path5.length;
                    if (!length) {
                        length = 1;
                        object = undefined2;
                    }
                    while(++index < length){
                        var value1 = object == null ? undefined2 : object[toKey(path5[index])];
                        if (value1 === undefined2) {
                            index = length;
                            value1 = defaultValue;
                        }
                        object = isFunction(value1) ? value1.call(object) : value1;
                    }
                    return object;
                }
                function set2(object, path5, value1) {
                    return object == null ? object : baseSet(object, path5, value1);
                }
                function setWith(object, path5, value1, customizer) {
                    customizer = typeof customizer == "function" ? customizer : undefined2;
                    return object == null ? object : baseSet(object, path5, value1, customizer);
                }
                var toPairs = createToPairs(keys);
                var toPairsIn = createToPairs(keysIn);
                function transform(object, iteratee2, accumulator) {
                    var isArr = isArray(object), isArrLike = isArr || isBuffer(object) || isTypedArray(object);
                    iteratee2 = getIteratee(iteratee2, 4);
                    if (accumulator == null) {
                        var Ctor = object && object.constructor;
                        if (isArrLike) {
                            accumulator = isArr ? new Ctor() : [];
                        } else if (isObject(object)) {
                            accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
                        } else {
                            accumulator = {};
                        }
                    }
                    (isArrLike ? arrayEach : baseForOwn)(object, function(value1, index, object2) {
                        return iteratee2(accumulator, value1, index, object2);
                    });
                    return accumulator;
                }
                function unset(object, path5) {
                    return object == null ? true : baseUnset(object, path5);
                }
                function update(object, path5, updater) {
                    return object == null ? object : baseUpdate(object, path5, castFunction(updater));
                }
                function updateWith(object, path5, updater, customizer) {
                    customizer = typeof customizer == "function" ? customizer : undefined2;
                    return object == null ? object : baseUpdate(object, path5, castFunction(updater), customizer);
                }
                function values(object) {
                    return object == null ? [] : baseValues(object, keys(object));
                }
                function valuesIn(object) {
                    return object == null ? [] : baseValues(object, keysIn(object));
                }
                function clamp(number, lower, upper) {
                    if (upper === undefined2) {
                        upper = lower;
                        lower = undefined2;
                    }
                    if (upper !== undefined2) {
                        upper = toNumber(upper);
                        upper = upper === upper ? upper : 0;
                    }
                    if (lower !== undefined2) {
                        lower = toNumber(lower);
                        lower = lower === lower ? lower : 0;
                    }
                    return baseClamp(toNumber(number), lower, upper);
                }
                function inRange(number, start, end) {
                    start = toFinite(start);
                    if (end === undefined2) {
                        end = start;
                        start = 0;
                    } else {
                        end = toFinite(end);
                    }
                    number = toNumber(number);
                    return baseInRange(number, start, end);
                }
                function random(lower, upper, floating) {
                    if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) {
                        upper = floating = undefined2;
                    }
                    if (floating === undefined2) {
                        if (typeof upper == "boolean") {
                            floating = upper;
                            upper = undefined2;
                        } else if (typeof lower == "boolean") {
                            floating = lower;
                            lower = undefined2;
                        }
                    }
                    if (lower === undefined2 && upper === undefined2) {
                        lower = 0;
                        upper = 1;
                    } else {
                        lower = toFinite(lower);
                        if (upper === undefined2) {
                            upper = lower;
                            lower = 0;
                        } else {
                            upper = toFinite(upper);
                        }
                    }
                    if (lower > upper) {
                        var temp = lower;
                        lower = upper;
                        upper = temp;
                    }
                    if (floating || lower % 1 || upper % 1) {
                        var rand = nativeRandom();
                        return nativeMin(lower + rand * (upper - lower + freeParseFloat("1e-" + ((rand + "").length - 1))), upper);
                    }
                    return baseRandom(lower, upper);
                }
                var camelCase = createCompounder(function(result2, word, index) {
                    word = word.toLowerCase();
                    return result2 + (index ? capitalize(word) : word);
                });
                function capitalize(string2) {
                    return upperFirst(toString(string2).toLowerCase());
                }
                function deburr(string2) {
                    string2 = toString(string2);
                    return string2 && string2.replace(reLatin, deburrLetter).replace(reComboMark, "");
                }
                function endsWith2(string2, target, position) {
                    string2 = toString(string2);
                    target = baseToString(target);
                    var length = string2.length;
                    position = position === undefined2 ? length : baseClamp(toInteger(position), 0, length);
                    var end = position;
                    position -= target.length;
                    return position >= 0 && string2.slice(position, end) == target;
                }
                function escape(string2) {
                    string2 = toString(string2);
                    return string2 && reHasUnescapedHtml.test(string2) ? string2.replace(reUnescapedHtml, escapeHtmlChar) : string2;
                }
                function escapeRegExp(string2) {
                    string2 = toString(string2);
                    return string2 && reHasRegExpChar.test(string2) ? string2.replace(reRegExpChar, "\\$&") : string2;
                }
                var kebabCase = createCompounder(function(result2, word, index) {
                    return result2 + (index ? "-" : "") + word.toLowerCase();
                });
                var lowerCase = createCompounder(function(result2, word, index) {
                    return result2 + (index ? " " : "") + word.toLowerCase();
                });
                var lowerFirst = createCaseFirst("toLowerCase");
                function pad(string2, length, chars) {
                    string2 = toString(string2);
                    length = toInteger(length);
                    var strLength = length ? stringSize(string2) : 0;
                    if (!length || strLength >= length) {
                        return string2;
                    }
                    var mid = (length - strLength) / 2;
                    return createPadding(nativeFloor(mid), chars) + string2 + createPadding(nativeCeil(mid), chars);
                }
                function padEnd(string2, length, chars) {
                    string2 = toString(string2);
                    length = toInteger(length);
                    var strLength = length ? stringSize(string2) : 0;
                    return length && strLength < length ? string2 + createPadding(length - strLength, chars) : string2;
                }
                function padStart(string2, length, chars) {
                    string2 = toString(string2);
                    length = toInteger(length);
                    var strLength = length ? stringSize(string2) : 0;
                    return length && strLength < length ? createPadding(length - strLength, chars) + string2 : string2;
                }
                function parseInt2(string2, radix, guard) {
                    if (guard || radix == null) {
                        radix = 0;
                    } else if (radix) {
                        radix = +radix;
                    }
                    return nativeParseInt(toString(string2).replace(reTrimStart, ""), radix || 0);
                }
                function repeat(string2, n, guard) {
                    if (guard ? isIterateeCall(string2, n, guard) : n === undefined2) {
                        n = 1;
                    } else {
                        n = toInteger(n);
                    }
                    return baseRepeat(toString(string2), n);
                }
                function replace() {
                    var args = arguments, string2 = toString(args[0]);
                    return args.length < 3 ? string2 : string2.replace(args[1], args[2]);
                }
                var snakeCase = createCompounder(function(result2, word, index) {
                    return result2 + (index ? "_" : "") + word.toLowerCase();
                });
                function split(string2, separator, limit) {
                    if (limit && typeof limit != "number" && isIterateeCall(string2, separator, limit)) {
                        separator = limit = undefined2;
                    }
                    limit = limit === undefined2 ? MAX_ARRAY_LENGTH : limit >>> 0;
                    if (!limit) {
                        return [];
                    }
                    string2 = toString(string2);
                    if (string2 && (typeof separator == "string" || separator != null && !isRegExp(separator))) {
                        separator = baseToString(separator);
                        if (!separator && hasUnicode(string2)) {
                            return castSlice(stringToArray(string2), 0, limit);
                        }
                    }
                    return string2.split(separator, limit);
                }
                var startCase = createCompounder(function(result2, word, index) {
                    return result2 + (index ? " " : "") + upperFirst(word);
                });
                function startsWith2(string2, target, position) {
                    string2 = toString(string2);
                    position = position == null ? 0 : baseClamp(toInteger(position), 0, string2.length);
                    target = baseToString(target);
                    return string2.slice(position, position + target.length) == target;
                }
                function template(string2, options, guard) {
                    var settings = lodash.templateSettings;
                    if (guard && isIterateeCall(string2, options, guard)) {
                        options = undefined2;
                    }
                    string2 = toString(string2);
                    options = assignInWith({}, options, settings, customDefaultsAssignIn);
                    var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);
                    var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = "__p += '";
                    var reDelimiters = RegExp2((options.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options.evaluate || reNoMatch).source + "|$", "g");
                    var sourceURL = "//# sourceURL=" + (hasOwnProperty.call(options, "sourceURL") ? (options.sourceURL + "").replace(/\s/g, " ") : "lodash.templateSources[" + ++templateCounter + "]") + "\n";
                    string2.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
                        interpolateValue || (interpolateValue = esTemplateValue);
                        source += string2.slice(index, offset).replace(reUnescapedString, escapeStringChar);
                        if (escapeValue) {
                            isEscaping = true;
                            source += "' +\n__e(" + escapeValue + ") +\n'";
                        }
                        if (evaluateValue) {
                            isEvaluating = true;
                            source += "';\n" + evaluateValue + ";\n__p += '";
                        }
                        if (interpolateValue) {
                            source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
                        }
                        index = offset + match.length;
                        return match;
                    });
                    source += "';\n";
                    var variable = hasOwnProperty.call(options, "variable") && options.variable;
                    if (!variable) {
                        source = "with (obj) {\n" + source + "\n}\n";
                    } else if (reForbiddenIdentifierChars.test(variable)) {
                        throw new Error2(INVALID_TEMPL_VAR_ERROR_TEXT);
                    }
                    source = (isEvaluating ? source.replace(reEmptyStringLeading, "") : source).replace(reEmptyStringMiddle, "$1").replace(reEmptyStringTrailing, "$1;");
                    source = "function(" + (variable || "obj") + ") {\n" + (variable ? "" : "obj || (obj = {});\n") + "var __t, __p = ''" + (isEscaping ? ", __e = _.escape" : "") + (isEvaluating ? ", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n" : ";\n") + source + "return __p\n}";
                    var result2 = attempt(function() {
                        return Function2(importsKeys, sourceURL + "return " + source).apply(undefined2, importsValues);
                    });
                    result2.source = source;
                    if (isError(result2)) {
                        throw result2;
                    }
                    return result2;
                }
                function toLower(value1) {
                    return toString(value1).toLowerCase();
                }
                function toUpper(value1) {
                    return toString(value1).toUpperCase();
                }
                function trim(string2, chars, guard) {
                    string2 = toString(string2);
                    if (string2 && (guard || chars === undefined2)) {
                        return baseTrim(string2);
                    }
                    if (!string2 || !(chars = baseToString(chars))) {
                        return string2;
                    }
                    var strSymbols = stringToArray(string2), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end = charsEndIndex(strSymbols, chrSymbols) + 1;
                    return castSlice(strSymbols, start, end).join("");
                }
                function trimEnd(string2, chars, guard) {
                    string2 = toString(string2);
                    if (string2 && (guard || chars === undefined2)) {
                        return string2.slice(0, trimmedEndIndex(string2) + 1);
                    }
                    if (!string2 || !(chars = baseToString(chars))) {
                        return string2;
                    }
                    var strSymbols = stringToArray(string2), end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;
                    return castSlice(strSymbols, 0, end).join("");
                }
                function trimStart(string2, chars, guard) {
                    string2 = toString(string2);
                    if (string2 && (guard || chars === undefined2)) {
                        return string2.replace(reTrimStart, "");
                    }
                    if (!string2 || !(chars = baseToString(chars))) {
                        return string2;
                    }
                    var strSymbols = stringToArray(string2), start = charsStartIndex(strSymbols, stringToArray(chars));
                    return castSlice(strSymbols, start).join("");
                }
                function truncate(string2, options) {
                    var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;
                    if (isObject(options)) {
                        var separator = "separator" in options ? options.separator : separator;
                        length = "length" in options ? toInteger(options.length) : length;
                        omission = "omission" in options ? baseToString(options.omission) : omission;
                    }
                    string2 = toString(string2);
                    var strLength = string2.length;
                    if (hasUnicode(string2)) {
                        var strSymbols = stringToArray(string2);
                        strLength = strSymbols.length;
                    }
                    if (length >= strLength) {
                        return string2;
                    }
                    var end = length - stringSize(omission);
                    if (end < 1) {
                        return omission;
                    }
                    var result2 = strSymbols ? castSlice(strSymbols, 0, end).join("") : string2.slice(0, end);
                    if (separator === undefined2) {
                        return result2 + omission;
                    }
                    if (strSymbols) {
                        end += result2.length - end;
                    }
                    if (isRegExp(separator)) {
                        if (string2.slice(end).search(separator)) {
                            var match, substring = result2;
                            if (!separator.global) {
                                separator = RegExp2(separator.source, toString(reFlags.exec(separator)) + "g");
                            }
                            separator.lastIndex = 0;
                            while(match = separator.exec(substring)){
                                var newEnd = match.index;
                            }
                            result2 = result2.slice(0, newEnd === undefined2 ? end : newEnd);
                        }
                    } else if (string2.indexOf(baseToString(separator), end) != end) {
                        var index = result2.lastIndexOf(separator);
                        if (index > -1) {
                            result2 = result2.slice(0, index);
                        }
                    }
                    return result2 + omission;
                }
                function unescape2(string2) {
                    string2 = toString(string2);
                    return string2 && reHasEscapedHtml.test(string2) ? string2.replace(reEscapedHtml, unescapeHtmlChar) : string2;
                }
                var upperCase = createCompounder(function(result2, word, index) {
                    return result2 + (index ? " " : "") + word.toUpperCase();
                });
                var upperFirst = createCaseFirst("toUpperCase");
                function words(string2, pattern, guard) {
                    string2 = toString(string2);
                    pattern = guard ? undefined2 : pattern;
                    if (pattern === undefined2) {
                        return hasUnicodeWord(string2) ? unicodeWords(string2) : asciiWords(string2);
                    }
                    return string2.match(pattern) || [];
                }
                var attempt = baseRest(function(func, args) {
                    try {
                        return apply(func, undefined2, args);
                    } catch (e) {
                        return isError(e) ? e : new Error2(e);
                    }
                });
                var bindAll = flatRest(function(object, methodNames) {
                    arrayEach(methodNames, function(key) {
                        key = toKey(key);
                        baseAssignValue(object, key, bind(object[key], object));
                    });
                    return object;
                });
                function cond(pairs2) {
                    var length = pairs2 == null ? 0 : pairs2.length, toIteratee = getIteratee();
                    pairs2 = !length ? [] : arrayMap(pairs2, function(pair) {
                        if (typeof pair[1] != "function") {
                            throw new TypeError2(FUNC_ERROR_TEXT);
                        }
                        return [
                            toIteratee(pair[0]),
                            pair[1]
                        ];
                    });
                    return baseRest(function(args) {
                        var index = -1;
                        while(++index < length){
                            var pair = pairs2[index];
                            if (apply(pair[0], this, args)) {
                                return apply(pair[1], this, args);
                            }
                        }
                    });
                }
                function conforms(source) {
                    return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
                }
                function constant(value1) {
                    return function() {
                        return value1;
                    };
                }
                function defaultTo(value1, defaultValue) {
                    return value1 == null || value1 !== value1 ? defaultValue : value1;
                }
                var flow = createFlow();
                var flowRight = createFlow(true);
                function identity(value1) {
                    return value1;
                }
                function iteratee(func) {
                    return baseIteratee(typeof func == "function" ? func : baseClone(func, CLONE_DEEP_FLAG));
                }
                function matches(source) {
                    return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
                }
                function matchesProperty(path5, srcValue) {
                    return baseMatchesProperty(path5, baseClone(srcValue, CLONE_DEEP_FLAG));
                }
                var method = baseRest(function(path5, args) {
                    return function(object) {
                        return baseInvoke(object, path5, args);
                    };
                });
                var methodOf = baseRest(function(object, args) {
                    return function(path5) {
                        return baseInvoke(object, path5, args);
                    };
                });
                function mixin(object, source, options) {
                    var props = keys(source), methodNames = baseFunctions(source, props);
                    if (options == null && !(isObject(source) && (methodNames.length || !props.length))) {
                        options = source;
                        source = object;
                        object = this;
                        methodNames = baseFunctions(source, keys(source));
                    }
                    var chain2 = !(isObject(options) && "chain" in options) || !!options.chain, isFunc = isFunction(object);
                    arrayEach(methodNames, function(methodName) {
                        var func = source[methodName];
                        object[methodName] = func;
                        if (isFunc) {
                            object.prototype[methodName] = function() {
                                var chainAll = this.__chain__;
                                if (chain2 || chainAll) {
                                    var result2 = object(this.__wrapped__), actions = result2.__actions__ = copyArray(this.__actions__);
                                    actions.push({
                                        "func": func,
                                        "args": arguments,
                                        "thisArg": object
                                    });
                                    result2.__chain__ = chainAll;
                                    return result2;
                                }
                                return func.apply(object, arrayPush([
                                    this.value()
                                ], arguments));
                            };
                        }
                    });
                    return object;
                }
                function noConflict() {
                    if (root._ === this) {
                        root._ = oldDash;
                    }
                    return this;
                }
                function noop() {}
                function nthArg(n) {
                    n = toInteger(n);
                    return baseRest(function(args) {
                        return baseNth(args, n);
                    });
                }
                var over = createOver(arrayMap);
                var overEvery = createOver(arrayEvery);
                var overSome = createOver(arraySome);
                function property(path5) {
                    return isKey(path5) ? baseProperty(toKey(path5)) : basePropertyDeep(path5);
                }
                function propertyOf(object) {
                    return function(path5) {
                        return object == null ? undefined2 : baseGet(object, path5);
                    };
                }
                var range = createRange3();
                var rangeRight = createRange3(true);
                function stubArray() {
                    return [];
                }
                function stubFalse() {
                    return false;
                }
                function stubObject() {
                    return {};
                }
                function stubString() {
                    return "";
                }
                function stubTrue() {
                    return true;
                }
                function times(n, iteratee2) {
                    n = toInteger(n);
                    if (n < 1 || n > MAX_SAFE_INTEGER) {
                        return [];
                    }
                    var index = MAX_ARRAY_LENGTH, length = nativeMin(n, MAX_ARRAY_LENGTH);
                    iteratee2 = getIteratee(iteratee2);
                    n -= MAX_ARRAY_LENGTH;
                    var result2 = baseTimes(length, iteratee2);
                    while(++index < n){
                        iteratee2(index);
                    }
                    return result2;
                }
                function toPath(value1) {
                    if (isArray(value1)) {
                        return arrayMap(value1, toKey);
                    }
                    return isSymbol(value1) ? [
                        value1
                    ] : copyArray(stringToPath(toString(value1)));
                }
                function uniqueId(prefix) {
                    var id = ++idCounter3;
                    return toString(prefix) + id;
                }
                var add = createMathOperation(function(augend, addend) {
                    return augend + addend;
                }, 0);
                var ceil = createRound("ceil");
                var divide = createMathOperation(function(dividend, divisor) {
                    return dividend / divisor;
                }, 1);
                var floor = createRound("floor");
                function max(array) {
                    return array && array.length ? baseExtremum(array, identity, baseGt) : undefined2;
                }
                function maxBy(array, iteratee2) {
                    return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseGt) : undefined2;
                }
                function mean(array) {
                    return baseMean(array, identity);
                }
                function meanBy(array, iteratee2) {
                    return baseMean(array, getIteratee(iteratee2, 2));
                }
                function min(array) {
                    return array && array.length ? baseExtremum(array, identity, baseLt) : undefined2;
                }
                function minBy(array, iteratee2) {
                    return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseLt) : undefined2;
                }
                var multiply = createMathOperation(function(multiplier, multiplicand) {
                    return multiplier * multiplicand;
                }, 1);
                var round = createRound("round");
                var subtract = createMathOperation(function(minuend, subtrahend) {
                    return minuend - subtrahend;
                }, 0);
                function sum(array) {
                    return array && array.length ? baseSum(array, identity) : 0;
                }
                function sumBy(array, iteratee2) {
                    return array && array.length ? baseSum(array, getIteratee(iteratee2, 2)) : 0;
                }
                lodash.after = after;
                lodash.ary = ary;
                lodash.assign = assign;
                lodash.assignIn = assignIn;
                lodash.assignInWith = assignInWith;
                lodash.assignWith = assignWith;
                lodash.at = at;
                lodash.before = before;
                lodash.bind = bind;
                lodash.bindAll = bindAll;
                lodash.bindKey = bindKey;
                lodash.castArray = castArray;
                lodash.chain = chain;
                lodash.chunk = chunk;
                lodash.compact = compact;
                lodash.concat = concat;
                lodash.cond = cond;
                lodash.conforms = conforms;
                lodash.constant = constant;
                lodash.countBy = countBy;
                lodash.create = create;
                lodash.curry = curry;
                lodash.curryRight = curryRight;
                lodash.debounce = debounce;
                lodash.defaults = defaults;
                lodash.defaultsDeep = defaultsDeep;
                lodash.defer = defer;
                lodash.delay = delay;
                lodash.difference = difference;
                lodash.differenceBy = differenceBy;
                lodash.differenceWith = differenceWith;
                lodash.drop = drop;
                lodash.dropRight = dropRight;
                lodash.dropRightWhile = dropRightWhile;
                lodash.dropWhile = dropWhile;
                lodash.fill = fill;
                lodash.filter = filter;
                lodash.flatMap = flatMap;
                lodash.flatMapDeep = flatMapDeep;
                lodash.flatMapDepth = flatMapDepth;
                lodash.flatten = flatten;
                lodash.flattenDeep = flattenDeep;
                lodash.flattenDepth = flattenDepth;
                lodash.flip = flip;
                lodash.flow = flow;
                lodash.flowRight = flowRight;
                lodash.fromPairs = fromPairs;
                lodash.functions = functions;
                lodash.functionsIn = functionsIn;
                lodash.groupBy = groupBy;
                lodash.initial = initial;
                lodash.intersection = intersection;
                lodash.intersectionBy = intersectionBy;
                lodash.intersectionWith = intersectionWith;
                lodash.invert = invert;
                lodash.invertBy = invertBy;
                lodash.invokeMap = invokeMap;
                lodash.iteratee = iteratee;
                lodash.keyBy = keyBy;
                lodash.keys = keys;
                lodash.keysIn = keysIn;
                lodash.map = map2;
                lodash.mapKeys = mapKeys;
                lodash.mapValues = mapValues;
                lodash.matches = matches;
                lodash.matchesProperty = matchesProperty;
                lodash.memoize = memoize;
                lodash.merge = merge;
                lodash.mergeWith = mergeWith;
                lodash.method = method;
                lodash.methodOf = methodOf;
                lodash.mixin = mixin;
                lodash.negate = negate;
                lodash.nthArg = nthArg;
                lodash.omit = omit;
                lodash.omitBy = omitBy;
                lodash.once = once;
                lodash.orderBy = orderBy;
                lodash.over = over;
                lodash.overArgs = overArgs;
                lodash.overEvery = overEvery;
                lodash.overSome = overSome;
                lodash.partial = partial;
                lodash.partialRight = partialRight;
                lodash.partition = partition;
                lodash.pick = pick;
                lodash.pickBy = pickBy;
                lodash.property = property;
                lodash.propertyOf = propertyOf;
                lodash.pull = pull;
                lodash.pullAll = pullAll;
                lodash.pullAllBy = pullAllBy;
                lodash.pullAllWith = pullAllWith;
                lodash.pullAt = pullAt;
                lodash.range = range;
                lodash.rangeRight = rangeRight;
                lodash.rearg = rearg;
                lodash.reject = reject;
                lodash.remove = remove;
                lodash.rest = rest;
                lodash.reverse = reverse;
                lodash.sampleSize = sampleSize;
                lodash.set = set2;
                lodash.setWith = setWith;
                lodash.shuffle = shuffle;
                lodash.slice = slice;
                lodash.sortBy = sortBy;
                lodash.sortedUniq = sortedUniq;
                lodash.sortedUniqBy = sortedUniqBy;
                lodash.split = split;
                lodash.spread = spread;
                lodash.tail = tail;
                lodash.take = take;
                lodash.takeRight = takeRight;
                lodash.takeRightWhile = takeRightWhile;
                lodash.takeWhile = takeWhile;
                lodash.tap = tap;
                lodash.throttle = throttle;
                lodash.thru = thru;
                lodash.toArray = toArray;
                lodash.toPairs = toPairs;
                lodash.toPairsIn = toPairsIn;
                lodash.toPath = toPath;
                lodash.toPlainObject = toPlainObject;
                lodash.transform = transform;
                lodash.unary = unary;
                lodash.union = union;
                lodash.unionBy = unionBy;
                lodash.unionWith = unionWith;
                lodash.uniq = uniq;
                lodash.uniqBy = uniqBy;
                lodash.uniqWith = uniqWith;
                lodash.unset = unset;
                lodash.unzip = unzip;
                lodash.unzipWith = unzipWith;
                lodash.update = update;
                lodash.updateWith = updateWith;
                lodash.values = values;
                lodash.valuesIn = valuesIn;
                lodash.without = without;
                lodash.words = words;
                lodash.wrap = wrap;
                lodash.xor = xor;
                lodash.xorBy = xorBy;
                lodash.xorWith = xorWith;
                lodash.zip = zip;
                lodash.zipObject = zipObject;
                lodash.zipObjectDeep = zipObjectDeep;
                lodash.zipWith = zipWith;
                lodash.entries = toPairs;
                lodash.entriesIn = toPairsIn;
                lodash.extend = assignIn;
                lodash.extendWith = assignInWith;
                mixin(lodash, lodash);
                lodash.add = add;
                lodash.attempt = attempt;
                lodash.camelCase = camelCase;
                lodash.capitalize = capitalize;
                lodash.ceil = ceil;
                lodash.clamp = clamp;
                lodash.clone = clone;
                lodash.cloneDeep = cloneDeep2;
                lodash.cloneDeepWith = cloneDeepWith;
                lodash.cloneWith = cloneWith;
                lodash.conformsTo = conformsTo;
                lodash.deburr = deburr;
                lodash.defaultTo = defaultTo;
                lodash.divide = divide;
                lodash.endsWith = endsWith2;
                lodash.eq = eq;
                lodash.escape = escape;
                lodash.escapeRegExp = escapeRegExp;
                lodash.every = every;
                lodash.find = find;
                lodash.findIndex = findIndex;
                lodash.findKey = findKey;
                lodash.findLast = findLast;
                lodash.findLastIndex = findLastIndex;
                lodash.findLastKey = findLastKey;
                lodash.floor = floor;
                lodash.forEach = forEach;
                lodash.forEachRight = forEachRight;
                lodash.forIn = forIn;
                lodash.forInRight = forInRight;
                lodash.forOwn = forOwn;
                lodash.forOwnRight = forOwnRight;
                lodash.get = get;
                lodash.gt = gt;
                lodash.gte = gte;
                lodash.has = has;
                lodash.hasIn = hasIn;
                lodash.head = head;
                lodash.identity = identity;
                lodash.includes = includes;
                lodash.indexOf = indexOf2;
                lodash.inRange = inRange;
                lodash.invoke = invoke;
                lodash.isArguments = isArguments;
                lodash.isArray = isArray;
                lodash.isArrayBuffer = isArrayBuffer;
                lodash.isArrayLike = isArrayLike;
                lodash.isArrayLikeObject = isArrayLikeObject;
                lodash.isBoolean = isBoolean3;
                lodash.isBuffer = isBuffer;
                lodash.isDate = isDate;
                lodash.isElement = isElement;
                lodash.isEmpty = isEmpty2;
                lodash.isEqual = isEqual;
                lodash.isEqualWith = isEqualWith;
                lodash.isError = isError;
                lodash.isFinite = isFinite2;
                lodash.isFunction = isFunction;
                lodash.isInteger = isInteger;
                lodash.isLength = isLength;
                lodash.isMap = isMap2;
                lodash.isMatch = isMatch;
                lodash.isMatchWith = isMatchWith;
                lodash.isNaN = isNaN2;
                lodash.isNative = isNative;
                lodash.isNil = isNil;
                lodash.isNull = isNull;
                lodash.isNumber = isNumber3;
                lodash.isObject = isObject;
                lodash.isObjectLike = isObjectLike;
                lodash.isPlainObject = isPlainObject;
                lodash.isRegExp = isRegExp;
                lodash.isSafeInteger = isSafeInteger;
                lodash.isSet = isSet;
                lodash.isString = isString3;
                lodash.isSymbol = isSymbol;
                lodash.isTypedArray = isTypedArray;
                lodash.isUndefined = isUndefined;
                lodash.isWeakMap = isWeakMap;
                lodash.isWeakSet = isWeakSet;
                lodash.join = join;
                lodash.kebabCase = kebabCase;
                lodash.last = last;
                lodash.lastIndexOf = lastIndexOf;
                lodash.lowerCase = lowerCase;
                lodash.lowerFirst = lowerFirst;
                lodash.lt = lt;
                lodash.lte = lte;
                lodash.max = max;
                lodash.maxBy = maxBy;
                lodash.mean = mean;
                lodash.meanBy = meanBy;
                lodash.min = min;
                lodash.minBy = minBy;
                lodash.stubArray = stubArray;
                lodash.stubFalse = stubFalse;
                lodash.stubObject = stubObject;
                lodash.stubString = stubString;
                lodash.stubTrue = stubTrue;
                lodash.multiply = multiply;
                lodash.nth = nth;
                lodash.noConflict = noConflict;
                lodash.noop = noop;
                lodash.now = now;
                lodash.pad = pad;
                lodash.padEnd = padEnd;
                lodash.padStart = padStart;
                lodash.parseInt = parseInt2;
                lodash.random = random;
                lodash.reduce = reduce;
                lodash.reduceRight = reduceRight;
                lodash.repeat = repeat;
                lodash.replace = replace;
                lodash.result = result;
                lodash.round = round;
                lodash.runInContext = runInContext2;
                lodash.sample = sample;
                lodash.size = size;
                lodash.snakeCase = snakeCase;
                lodash.some = some;
                lodash.sortedIndex = sortedIndex;
                lodash.sortedIndexBy = sortedIndexBy;
                lodash.sortedIndexOf = sortedIndexOf;
                lodash.sortedLastIndex = sortedLastIndex;
                lodash.sortedLastIndexBy = sortedLastIndexBy;
                lodash.sortedLastIndexOf = sortedLastIndexOf;
                lodash.startCase = startCase;
                lodash.startsWith = startsWith2;
                lodash.subtract = subtract;
                lodash.sum = sum;
                lodash.sumBy = sumBy;
                lodash.template = template;
                lodash.times = times;
                lodash.toFinite = toFinite;
                lodash.toInteger = toInteger;
                lodash.toLength = toLength;
                lodash.toLower = toLower;
                lodash.toNumber = toNumber;
                lodash.toSafeInteger = toSafeInteger;
                lodash.toString = toString;
                lodash.toUpper = toUpper;
                lodash.trim = trim;
                lodash.trimEnd = trimEnd;
                lodash.trimStart = trimStart;
                lodash.truncate = truncate;
                lodash.unescape = unescape2;
                lodash.uniqueId = uniqueId;
                lodash.upperCase = upperCase;
                lodash.upperFirst = upperFirst;
                lodash.each = forEach;
                lodash.eachRight = forEachRight;
                lodash.first = head;
                mixin(lodash, function() {
                    var source = {};
                    baseForOwn(lodash, function(func, methodName) {
                        if (!hasOwnProperty.call(lodash.prototype, methodName)) {
                            source[methodName] = func;
                        }
                    });
                    return source;
                }(), {
                    "chain": false
                });
                lodash.VERSION = VERSION;
                arrayEach([
                    "bind",
                    "bindKey",
                    "curry",
                    "curryRight",
                    "partial",
                    "partialRight"
                ], function(methodName) {
                    lodash[methodName].placeholder = lodash;
                });
                arrayEach([
                    "drop",
                    "take"
                ], function(methodName, index) {
                    LazyWrapper.prototype[methodName] = function(n) {
                        n = n === undefined2 ? 1 : nativeMax(toInteger(n), 0);
                        var result2 = this.__filtered__ && !index ? new LazyWrapper(this) : this.clone();
                        if (result2.__filtered__) {
                            result2.__takeCount__ = nativeMin(n, result2.__takeCount__);
                        } else {
                            result2.__views__.push({
                                "size": nativeMin(n, MAX_ARRAY_LENGTH),
                                "type": methodName + (result2.__dir__ < 0 ? "Right" : "")
                            });
                        }
                        return result2;
                    };
                    LazyWrapper.prototype[methodName + "Right"] = function(n) {
                        return this.reverse()[methodName](n).reverse();
                    };
                });
                arrayEach([
                    "filter",
                    "map",
                    "takeWhile"
                ], function(methodName, index) {
                    var type = index + 1, isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
                    LazyWrapper.prototype[methodName] = function(iteratee2) {
                        var result2 = this.clone();
                        result2.__iteratees__.push({
                            "iteratee": getIteratee(iteratee2, 3),
                            "type": type
                        });
                        result2.__filtered__ = result2.__filtered__ || isFilter;
                        return result2;
                    };
                });
                arrayEach([
                    "head",
                    "last"
                ], function(methodName, index) {
                    var takeName = "take" + (index ? "Right" : "");
                    LazyWrapper.prototype[methodName] = function() {
                        return this[takeName](1).value()[0];
                    };
                });
                arrayEach([
                    "initial",
                    "tail"
                ], function(methodName, index) {
                    var dropName = "drop" + (index ? "" : "Right");
                    LazyWrapper.prototype[methodName] = function() {
                        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
                    };
                });
                LazyWrapper.prototype.compact = function() {
                    return this.filter(identity);
                };
                LazyWrapper.prototype.find = function(predicate) {
                    return this.filter(predicate).head();
                };
                LazyWrapper.prototype.findLast = function(predicate) {
                    return this.reverse().find(predicate);
                };
                LazyWrapper.prototype.invokeMap = baseRest(function(path5, args) {
                    if (typeof path5 == "function") {
                        return new LazyWrapper(this);
                    }
                    return this.map(function(value1) {
                        return baseInvoke(value1, path5, args);
                    });
                });
                LazyWrapper.prototype.reject = function(predicate) {
                    return this.filter(negate(getIteratee(predicate)));
                };
                LazyWrapper.prototype.slice = function(start, end) {
                    start = toInteger(start);
                    var result2 = this;
                    if (result2.__filtered__ && (start > 0 || end < 0)) {
                        return new LazyWrapper(result2);
                    }
                    if (start < 0) {
                        result2 = result2.takeRight(-start);
                    } else if (start) {
                        result2 = result2.drop(start);
                    }
                    if (end !== undefined2) {
                        end = toInteger(end);
                        result2 = end < 0 ? result2.dropRight(-end) : result2.take(end - start);
                    }
                    return result2;
                };
                LazyWrapper.prototype.takeRightWhile = function(predicate) {
                    return this.reverse().takeWhile(predicate).reverse();
                };
                LazyWrapper.prototype.toArray = function() {
                    return this.take(MAX_ARRAY_LENGTH);
                };
                baseForOwn(LazyWrapper.prototype, function(func, methodName) {
                    var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);
                    if (!lodashFunc) {
                        return;
                    }
                    lodash.prototype[methodName] = function() {
                        var value1 = this.__wrapped__, args = isTaker ? [
                            1
                        ] : arguments, isLazy = value1 instanceof LazyWrapper, iteratee2 = args[0], useLazy = isLazy || isArray(value1);
                        var interceptor = function(value2) {
                            var result3 = lodashFunc.apply(lodash, arrayPush([
                                value2
                            ], args));
                            return isTaker && chainAll ? result3[0] : result3;
                        };
                        if (useLazy && checkIteratee && typeof iteratee2 == "function" && iteratee2.length != 1) {
                            isLazy = useLazy = false;
                        }
                        var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;
                        if (!retUnwrapped && useLazy) {
                            value1 = onlyLazy ? value1 : new LazyWrapper(this);
                            var result2 = func.apply(value1, args);
                            result2.__actions__.push({
                                "func": thru,
                                "args": [
                                    interceptor
                                ],
                                "thisArg": undefined2
                            });
                            return new LodashWrapper(result2, chainAll);
                        }
                        if (isUnwrapped && onlyLazy) {
                            return func.apply(this, args);
                        }
                        result2 = this.thru(interceptor);
                        return isUnwrapped ? isTaker ? result2.value()[0] : result2.value() : result2;
                    };
                });
                arrayEach([
                    "pop",
                    "push",
                    "shift",
                    "sort",
                    "splice",
                    "unshift"
                ], function(methodName) {
                    var func = arrayProto[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName);
                    lodash.prototype[methodName] = function() {
                        var args = arguments;
                        if (retUnwrapped && !this.__chain__) {
                            var value1 = this.value();
                            return func.apply(isArray(value1) ? value1 : [], args);
                        }
                        return this[chainName](function(value2) {
                            return func.apply(isArray(value2) ? value2 : [], args);
                        });
                    };
                });
                baseForOwn(LazyWrapper.prototype, function(func, methodName) {
                    var lodashFunc = lodash[methodName];
                    if (lodashFunc) {
                        var key = lodashFunc.name + "";
                        if (!hasOwnProperty.call(realNames, key)) {
                            realNames[key] = [];
                        }
                        realNames[key].push({
                            "name": methodName,
                            "func": lodashFunc
                        });
                    }
                });
                realNames[createHybrid(undefined2, WRAP_BIND_KEY_FLAG).name] = [
                    {
                        "name": "wrapper",
                        "func": undefined2
                    }
                ];
                LazyWrapper.prototype.clone = lazyClone;
                LazyWrapper.prototype.reverse = lazyReverse;
                LazyWrapper.prototype.value = lazyValue;
                lodash.prototype.at = wrapperAt;
                lodash.prototype.chain = wrapperChain;
                lodash.prototype.commit = wrapperCommit;
                lodash.prototype.next = wrapperNext;
                lodash.prototype.plant = wrapperPlant;
                lodash.prototype.reverse = wrapperReverse;
                lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
                lodash.prototype.first = lodash.prototype.head;
                if (symIterator) {
                    lodash.prototype[symIterator] = wrapperToIterator;
                }
                return lodash;
            };
            var _2 = runInContext();
            if (typeof define == "function" && "object" == "object" && __webpack_require__.amdO) {
                root._ = _2;
                define(function() {
                    return _2;
                });
            } else if (freeModule) {
                (freeModule.exports = _2)._ = _2;
                freeExports._ = _2;
            } else {
                root._ = _2;
            }
        }).call(exports);
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/ral.js
var require_ral = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/ral.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        var _ral;
        function RAL() {
            if (_ral === void 0) {
                throw new Error(`No runtime abstraction layer installed`);
            }
            return _ral;
        }
        (function(RAL2) {
            function install(ral) {
                if (ral === void 0) {
                    throw new Error(`No runtime abstraction layer provided`);
                }
                _ral = ral;
            }
            RAL2.install = install;
        })(RAL || (RAL = {}));
        exports.default = RAL;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/disposable.js
var require_disposable = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/disposable.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.Disposable = void 0;
        var Disposable;
        (function(Disposable2) {
            function create(func) {
                return {
                    dispose: func
                };
            }
            Disposable2.create = create;
        })(Disposable = exports.Disposable || (exports.Disposable = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/events.js
var require_events = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/events.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.Emitter = exports.Event = void 0;
        var ral_1 = require_ral();
        var Event;
        (function(Event2) {
            const _disposable = {
                dispose () {}
            };
            Event2.None = function() {
                return _disposable;
            };
        })(Event = exports.Event || (exports.Event = {}));
        var CallbackList = class {
            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) {
                            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) {
                        ral_1.default().console.error(e);
                    }
                }
                return ret;
            }
            isEmpty() {
                return !this._callbacks || this._callbacks.length === 0;
            }
            dispose() {
                this._callbacks = void 0;
                this._contexts = void 0;
            }
        };
        var Emitter = class _Emitter {
            /**
       * 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) {
                                    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 = void 0;
                }
            }
            constructor(_options){
                this._options = _options;
            }
        };
        exports.Emitter = Emitter;
        Emitter._noop = function() {};
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js
var require_messageBuffer = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.AbstractMessageBuffer = void 0;
        var CR = 13;
        var LF = 10;
        var CRLF = "\r\n";
        var AbstractMessageBuffer = class {
            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() {
                if (this._chunks.length === 0) {
                    return void 0;
                }
                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 value1 = chunk[offset];
                        switch(value1){
                            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 void 0;
                }
                const buffer = this._read(chunkBytesRead + offset);
                const result = /* @__PURE__ */ 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 value1 = header.substr(index + 1).trim();
                    result.set(key, value1);
                }
                return result;
            }
            tryReadBody(length) {
                if (this._totalLength < length) {
                    return void 0;
                }
                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) {
                    const chunk = this._chunks[0];
                    this._chunks.shift();
                    this._totalLength -= byteCount;
                    return this.asNative(chunk);
                }
                if (this._chunks[0].byteLength > byteCount) {
                    const chunk = this._chunks[0];
                    const result2 = this.asNative(chunk, byteCount);
                    this._chunks[0] = chunk.slice(byteCount);
                    this._totalLength -= byteCount;
                    return result2;
                }
                const result = this.allocNative(byteCount);
                let resultOffset = 0;
                let chunkIndex = 0;
                while(byteCount > 0){
                    const chunk = this._chunks[chunkIndex];
                    if (chunk.byteLength > byteCount) {
                        const chunkPart = chunk.slice(0, byteCount);
                        result.set(chunkPart, resultOffset);
                        resultOffset += byteCount;
                        this._chunks[chunkIndex] = chunk.slice(byteCount);
                        this._totalLength -= byteCount;
                        byteCount -= byteCount;
                    } else {
                        result.set(chunk, resultOffset);
                        resultOffset += chunk.byteLength;
                        this._chunks.shift();
                        this._totalLength -= chunk.byteLength;
                        byteCount -= chunk.byteLength;
                    }
                }
                return result;
            }
            constructor(encoding = "utf-8"){
                this._encoding = encoding;
                this._chunks = [];
                this._totalLength = 0;
            }
        };
        exports.AbstractMessageBuffer = AbstractMessageBuffer;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/browser/ril.js
var require_ril = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/browser/ril.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        var ral_1 = require_ral();
        var disposable_1 = require_disposable();
        var events_1 = require_events();
        var messageBuffer_1 = require_messageBuffer();
        var MessageBuffer = class _MessageBuffer extends messageBuffer_1.AbstractMessageBuffer {
            emptyBuffer() {
                return _MessageBuffer.emptyBuffer;
            }
            fromString(value1, _encoding) {
                return new TextEncoder().encode(value1);
            }
            toString(value1, encoding) {
                if (encoding === "ascii") {
                    return this.asciiDecoder.decode(value1);
                } else {
                    return new TextDecoder(encoding).decode(value1);
                }
            }
            asNative(buffer, length) {
                if (length === void 0) {
                    return buffer;
                } else {
                    return buffer.slice(0, length);
                }
            }
            allocNative(length) {
                return new Uint8Array(length);
            }
            constructor(encoding = "utf-8"){
                super(encoding);
                this.asciiDecoder = new TextDecoder("ascii");
            }
        };
        MessageBuffer.emptyBuffer = new Uint8Array(0);
        var ReadableStreamWrapper = class {
            onClose(listener) {
                this.socket.addEventListener("close", listener);
                return disposable_1.Disposable.create(()=>this.socket.removeEventListener("close", listener));
            }
            onError(listener) {
                this.socket.addEventListener("error", listener);
                return disposable_1.Disposable.create(()=>this.socket.removeEventListener("error", listener));
            }
            onEnd(listener) {
                this.socket.addEventListener("end", listener);
                return disposable_1.Disposable.create(()=>this.socket.removeEventListener("end", listener));
            }
            onData(listener) {
                return this._onData.event(listener);
            }
            constructor(socket){
                this.socket = socket;
                this._onData = new events_1.Emitter();
                this._messageListener = (event)=>{
                    const blob = event.data;
                    blob.arrayBuffer().then((buffer)=>{
                        this._onData.fire(new Uint8Array(buffer));
                    });
                };
                this.socket.addEventListener("message", this._messageListener);
            }
        };
        var WritableStreamWrapper = class {
            onClose(listener) {
                this.socket.addEventListener("close", listener);
                return disposable_1.Disposable.create(()=>this.socket.removeEventListener("close", listener));
            }
            onError(listener) {
                this.socket.addEventListener("error", listener);
                return disposable_1.Disposable.create(()=>this.socket.removeEventListener("error", listener));
            }
            onEnd(listener) {
                this.socket.addEventListener("end", listener);
                return disposable_1.Disposable.create(()=>this.socket.removeEventListener("end", listener));
            }
            write(data, encoding) {
                if (typeof data === "string") {
                    if (encoding !== void 0 && encoding !== "utf-8") {
                        throw new Error(`In a Browser environments only utf-8 text encding is supported. But got encoding: ${encoding}`);
                    }
                    this.socket.send(data);
                } else {
                    this.socket.send(data);
                }
                return Promise.resolve();
            }
            end() {
                this.socket.close();
            }
            constructor(socket){
                this.socket = socket;
            }
        };
        var _textEncoder = new TextEncoder();
        var _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 encding is supported. But got encoding: ${options.charset}`);
                        }
                        return Promise.resolve(_textEncoder.encode(JSON.stringify(msg, void 0, 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,
            timer: Object.freeze({
                setTimeout (callback, ms, ...args) {
                    return setTimeout(callback, ms, ...args);
                },
                clearTimeout (handle) {
                    clearTimeout(handle);
                },
                setImmediate (callback, ...args) {
                    return setTimeout(callback, 0, ...args);
                },
                clearImmediate (handle) {
                    clearTimeout(handle);
                }
            })
        });
        function RIL() {
            return _ril;
        }
        (function(RIL2) {
            function install() {
                ral_1.default.install(_ril);
            }
            RIL2.install = install;
        })(RIL || (RIL = {}));
        exports.default = RIL;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/is.js
var require_is = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/is.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
        function boolean(value1) {
            return value1 === true || value1 === false;
        }
        exports.boolean = boolean;
        function string2(value1) {
            return typeof value1 === "string" || value1 instanceof String;
        }
        exports.string = string2;
        function number(value1) {
            return typeof value1 === "number" || value1 instanceof Number;
        }
        exports.number = number;
        function error(value1) {
            return value1 instanceof Error;
        }
        exports.error = error;
        function func(value1) {
            return typeof value1 === "function";
        }
        exports.func = func;
        function array(value1) {
            return Array.isArray(value1);
        }
        exports.array = array;
        function stringArray(value1) {
            return array(value1) && value1.every((elem)=>string2(elem));
        }
        exports.stringArray = stringArray;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/messages.js
var require_messages = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/messages.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.isResponseMessage = exports.isNotificationMessage = exports.isRequestMessage = 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;
        var is = require_is();
        var ErrorCodes;
        (function(ErrorCodes2) {
            ErrorCodes2.ParseError = -32700;
            ErrorCodes2.InvalidRequest = -32600;
            ErrorCodes2.MethodNotFound = -32601;
            ErrorCodes2.InvalidParams = -32602;
            ErrorCodes2.InternalError = -32603;
            ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099;
            ErrorCodes2.serverErrorStart = ErrorCodes2.jsonrpcReservedErrorRangeStart;
            ErrorCodes2.MessageWriteError = -32099;
            ErrorCodes2.MessageReadError = -32098;
            ErrorCodes2.ServerNotInitialized = -32002;
            ErrorCodes2.UnknownErrorCode = -32001;
            ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3;
            ErrorCodes2.serverErrorEnd = ErrorCodes2.jsonrpcReservedErrorRangeEnd;
        })(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {}));
        var ResponseError = class _ResponseError extends Error {
            toJson() {
                return {
                    code: this.code,
                    message: this.message,
                    data: this.data
                };
            }
            constructor(code, message, data){
                super(message);
                this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
                this.data = data;
                Object.setPrototypeOf(this, _ResponseError.prototype);
            }
        };
        exports.ResponseError = ResponseError;
        var ParameterStructures = class _ParameterStructures {
            static is(value1) {
                return value1 === _ParameterStructures.auto || value1 === _ParameterStructures.byName || value1 === _ParameterStructures.byPosition;
            }
            toString() {
                return this.kind;
            }
            constructor(kind){
                this.kind = kind;
            }
        };
        exports.ParameterStructures = ParameterStructures;
        ParameterStructures.auto = new ParameterStructures("auto");
        ParameterStructures.byPosition = new ParameterStructures("byPosition");
        ParameterStructures.byName = new ParameterStructures("byName");
        var AbstractMessageSignature = class {
            get parameterStructures() {
                return ParameterStructures.auto;
            }
            constructor(method, numberOfParams){
                this.method = method;
                this.numberOfParams = numberOfParams;
            }
        };
        exports.AbstractMessageSignature = AbstractMessageSignature;
        var RequestType0 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 0);
            }
        };
        exports.RequestType0 = RequestType0;
        var RequestType = class extends AbstractMessageSignature {
            get parameterStructures() {
                return this._parameterStructures;
            }
            constructor(method, _parameterStructures = ParameterStructures.auto){
                super(method, 1);
                this._parameterStructures = _parameterStructures;
            }
        };
        exports.RequestType = RequestType;
        var RequestType1 = class extends AbstractMessageSignature {
            get parameterStructures() {
                return this._parameterStructures;
            }
            constructor(method, _parameterStructures = ParameterStructures.auto){
                super(method, 1);
                this._parameterStructures = _parameterStructures;
            }
        };
        exports.RequestType1 = RequestType1;
        var RequestType2 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 2);
            }
        };
        exports.RequestType2 = RequestType2;
        var RequestType3 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 3);
            }
        };
        exports.RequestType3 = RequestType3;
        var RequestType4 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 4);
            }
        };
        exports.RequestType4 = RequestType4;
        var RequestType5 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 5);
            }
        };
        exports.RequestType5 = RequestType5;
        var RequestType6 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 6);
            }
        };
        exports.RequestType6 = RequestType6;
        var RequestType7 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 7);
            }
        };
        exports.RequestType7 = RequestType7;
        var RequestType8 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 8);
            }
        };
        exports.RequestType8 = RequestType8;
        var RequestType9 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 9);
            }
        };
        exports.RequestType9 = RequestType9;
        var NotificationType = class extends AbstractMessageSignature {
            get parameterStructures() {
                return this._parameterStructures;
            }
            constructor(method, _parameterStructures = ParameterStructures.auto){
                super(method, 1);
                this._parameterStructures = _parameterStructures;
            }
        };
        exports.NotificationType = NotificationType;
        var NotificationType0 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 0);
            }
        };
        exports.NotificationType0 = NotificationType0;
        var NotificationType1 = class extends AbstractMessageSignature {
            get parameterStructures() {
                return this._parameterStructures;
            }
            constructor(method, _parameterStructures = ParameterStructures.auto){
                super(method, 1);
                this._parameterStructures = _parameterStructures;
            }
        };
        exports.NotificationType1 = NotificationType1;
        var NotificationType2 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 2);
            }
        };
        exports.NotificationType2 = NotificationType2;
        var NotificationType3 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 3);
            }
        };
        exports.NotificationType3 = NotificationType3;
        var NotificationType4 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 4);
            }
        };
        exports.NotificationType4 = NotificationType4;
        var NotificationType5 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 5);
            }
        };
        exports.NotificationType5 = NotificationType5;
        var NotificationType6 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 6);
            }
        };
        exports.NotificationType6 = NotificationType6;
        var NotificationType7 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 7);
            }
        };
        exports.NotificationType7 = NotificationType7;
        var NotificationType8 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 8);
            }
        };
        exports.NotificationType8 = NotificationType8;
        var NotificationType9 = class extends AbstractMessageSignature {
            constructor(method){
                super(method, 9);
            }
        };
        exports.NotificationType9 = NotificationType9;
        function isRequestMessage(message) {
            const candidate = message;
            return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
        }
        exports.isRequestMessage = isRequestMessage;
        function isNotificationMessage(message) {
            const candidate = message;
            return candidate && is.string(candidate.method) && message.id === void 0;
        }
        exports.isNotificationMessage = isNotificationMessage;
        function isResponseMessage(message) {
            const candidate = message;
            return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
        }
        exports.isResponseMessage = isResponseMessage;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/cancellation.js
var require_cancellation = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/cancellation.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.CancellationTokenSource = exports.CancellationToken = void 0;
        var ral_1 = require_ral();
        var Is = require_is();
        var events_1 = require_events();
        var CancellationToken;
        (function(CancellationToken2) {
            CancellationToken2.None = Object.freeze({
                isCancellationRequested: false,
                onCancellationRequested: events_1.Event.None
            });
            CancellationToken2.Cancelled = Object.freeze({
                isCancellationRequested: true,
                onCancellationRequested: events_1.Event.None
            });
            function is(value1) {
                const candidate = value1;
                return candidate && (candidate === CancellationToken2.None || candidate === CancellationToken2.Cancelled || Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
            }
            CancellationToken2.is = is;
        })(CancellationToken = exports.CancellationToken || (exports.CancellationToken = {}));
        var shortcutEvent = Object.freeze(function(callback, context) {
            const handle = ral_1.default().timer.setTimeout(callback.bind(context), 0);
            return {
                dispose () {
                    ral_1.default().timer.clearTimeout(handle);
                }
            };
        });
        var MutableToken = class {
            cancel() {
                if (!this._isCancelled) {
                    this._isCancelled = true;
                    if (this._emitter) {
                        this._emitter.fire(void 0);
                        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 = void 0;
                }
            }
            constructor(){
                this._isCancelled = false;
            }
        };
        var CancellationTokenSource = class {
            get token() {
                if (!this._token) {
                    this._token = new MutableToken();
                }
                return this._token;
            }
            cancel() {
                if (!this._token) {
                    this._token = CancellationToken.Cancelled;
                } else {
                    this._token.cancel();
                }
            }
            dispose() {
                if (!this._token) {
                    this._token = CancellationToken.None;
                } else if (this._token instanceof MutableToken) {
                    this._token.dispose();
                }
            }
        };
        exports.CancellationTokenSource = CancellationTokenSource;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/messageReader.js
var require_messageReader = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/messageReader.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = void 0;
        var ral_1 = require_ral();
        var Is = require_is();
        var events_1 = require_events();
        var MessageReader;
        (function(MessageReader2) {
            function is(value1) {
                let candidate = value1;
                return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) && Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);
            }
            MessageReader2.is = is;
        })(MessageReader = exports.MessageReader || (exports.MessageReader = {}));
        var AbstractMessageReader = class {
            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(void 0);
            }
            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"}`);
                }
            }
            constructor(){
                this.errorEmitter = new events_1.Emitter();
                this.closeEmitter = new events_1.Emitter();
                this.partialMessageEmitter = new events_1.Emitter();
            }
        };
        exports.AbstractMessageReader = AbstractMessageReader;
        var ResolvedMessageReaderOptions;
        (function(ResolvedMessageReaderOptions2) {
            function fromOptions(options) {
                var _a;
                let charset;
                let result;
                let contentDecoder;
                const contentDecoders = /* @__PURE__ */ new Map();
                let contentTypeDecoder;
                const contentTypeDecoders = /* @__PURE__ */ new Map();
                if (options === void 0 || typeof options === "string") {
                    charset = options !== null && options !== void 0 ? options : "utf-8";
                } else {
                    charset = (_a = options.charset) !== null && _a !== void 0 ? _a : "utf-8";
                    if (options.contentDecoder !== void 0) {
                        contentDecoder = options.contentDecoder;
                        contentDecoders.set(contentDecoder.name, contentDecoder);
                    }
                    if (options.contentDecoders !== void 0) {
                        for (const decoder of options.contentDecoders){
                            contentDecoders.set(decoder.name, decoder);
                        }
                    }
                    if (options.contentTypeDecoder !== void 0) {
                        contentTypeDecoder = options.contentTypeDecoder;
                        contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
                    }
                    if (options.contentTypeDecoders !== void 0) {
                        for (const decoder of options.contentTypeDecoders){
                            contentTypeDecoders.set(decoder.name, decoder);
                        }
                    }
                }
                if (contentTypeDecoder === void 0) {
                    contentTypeDecoder = ral_1.default().applicationJson.decoder;
                    contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
                }
                return {
                    charset,
                    contentDecoder,
                    contentDecoders,
                    contentTypeDecoder,
                    contentTypeDecoders
                };
            }
            ResolvedMessageReaderOptions2.fromOptions = fromOptions;
        })(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
        var ReadableStreamMessageReader = class extends AbstractMessageReader {
            set partialMessageTimeout(timeout) {
                this._partialMessageTimeout = timeout;
            }
            get partialMessageTimeout() {
                return this._partialMessageTimeout;
            }
            listen(callback) {
                this.nextMessageLength = -1;
                this.messageToken = 0;
                this.partialMessageTimer = void 0;
                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();
                        if (!headers) {
                            return;
                        }
                        const contentLength = headers.get("Content-Length");
                        if (!contentLength) {
                            throw new Error("Header must provide a Content-Length property.");
                        }
                        const length = parseInt(contentLength);
                        if (isNaN(length)) {
                            throw new Error("Content-Length value must be a number.");
                        }
                        this.nextMessageLength = length;
                    }
                    const body = this.buffer.tryReadBody(this.nextMessageLength);
                    if (body === void 0) {
                        this.setPartialMessageTimer();
                        return;
                    }
                    this.clearPartialMessageTimer();
                    this.nextMessageLength = -1;
                    let p;
                    if (this.options.contentDecoder !== void 0) {
                        p = this.options.contentDecoder.decode(body);
                    } else {
                        p = Promise.resolve(body);
                    }
                    p.then((value1)=>{
                        this.options.contentTypeDecoder.decode(value1, this.options).then((msg)=>{
                            this.callback(msg);
                        }, (error)=>{
                            this.fireError(error);
                        });
                    }, (error)=>{
                        this.fireError(error);
                    });
                }
            }
            clearPartialMessageTimer() {
                if (this.partialMessageTimer) {
                    ral_1.default().timer.clearTimeout(this.partialMessageTimer);
                    this.partialMessageTimer = void 0;
                }
            }
            setPartialMessageTimer() {
                this.clearPartialMessageTimer();
                if (this._partialMessageTimeout <= 0) {
                    return;
                }
                this.partialMessageTimer = ral_1.default().timer.setTimeout((token, timeout)=>{
                    this.partialMessageTimer = void 0;
                    if (token === this.messageToken) {
                        this.firePartialMessage({
                            messageToken: token,
                            waitingTime: timeout
                        });
                        this.setPartialMessageTimer();
                    }
                }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
            }
            constructor(readable, options){
                super();
                this.readable = readable;
                this.options = ResolvedMessageReaderOptions.fromOptions(options);
                this.buffer = ral_1.default().messageBuffer.create(this.options.charset);
                this._partialMessageTimeout = 1e4;
                this.nextMessageLength = -1;
                this.messageToken = 0;
            }
        };
        exports.ReadableStreamMessageReader = ReadableStreamMessageReader;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/semaphore.js
var require_semaphore = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/semaphore.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.Semaphore = void 0;
        var ral_1 = require_ral();
        var Semaphore = class {
            lock(thunk) {
                return new Promise((resolve2, reject)=>{
                    this._waiting.push({
                        thunk,
                        resolve: resolve2,
                        reject
                    });
                    this.runNext();
                });
            }
            get active() {
                return this._active;
            }
            runNext() {
                if (this._waiting.length === 0 || this._active === this._capacity) {
                    return;
                }
                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((value1)=>{
                            this._active--;
                            next.resolve(value1);
                            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();
                }
            }
            constructor(capacity = 1){
                if (capacity <= 0) {
                    throw new Error("Capacity must be greater than 0");
                }
                this._capacity = capacity;
                this._active = 0;
                this._waiting = [];
            }
        };
        exports.Semaphore = Semaphore;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/messageWriter.js
var require_messageWriter = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/messageWriter.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = void 0;
        var ral_1 = require_ral();
        var Is = require_is();
        var semaphore_1 = require_semaphore();
        var events_1 = require_events();
        var ContentLength = "Content-Length: ";
        var CRLF = "\r\n";
        var MessageWriter;
        (function(MessageWriter2) {
            function is(value1) {
                let candidate = value1;
                return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) && Is.func(candidate.onError) && Is.func(candidate.write);
            }
            MessageWriter2.is = is;
        })(MessageWriter = exports.MessageWriter || (exports.MessageWriter = {}));
        var AbstractMessageWriter = class {
            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(void 0);
            }
            asError(error) {
                if (error instanceof Error) {
                    return error;
                } else {
                    return new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : "unknown"}`);
                }
            }
            constructor(){
                this.errorEmitter = new events_1.Emitter();
                this.closeEmitter = new events_1.Emitter();
            }
        };
        exports.AbstractMessageWriter = AbstractMessageWriter;
        var ResolvedMessageWriterOptions;
        (function(ResolvedMessageWriterOptions2) {
            function fromOptions(options) {
                var _a, _b;
                if (options === void 0 || typeof options === "string") {
                    return {
                        charset: options !== null && options !== void 0 ? options : "utf-8",
                        contentTypeEncoder: ral_1.default().applicationJson.encoder
                    };
                } else {
                    return {
                        charset: (_a = options.charset) !== null && _a !== void 0 ? _a : "utf-8",
                        contentEncoder: options.contentEncoder,
                        contentTypeEncoder: (_b = options.contentTypeEncoder) !== null && _b !== void 0 ? _b : ral_1.default().applicationJson.encoder
                    };
                }
            }
            ResolvedMessageWriterOptions2.fromOptions = fromOptions;
        })(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
        var WriteableStreamMessageWriter = class extends AbstractMessageWriter {
            async write(msg) {
                return this.writeSemaphore.lock(async ()=>{
                    const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer)=>{
                        if (this.options.contentEncoder !== void 0) {
                            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();
            }
            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());
            }
        };
        exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/linkedMap.js
var require_linkedMap = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/linkedMap.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.LRUCache = exports.LinkedMap = exports.Touch = void 0;
        var Touch;
        (function(Touch2) {
            Touch2.None = 0;
            Touch2.First = 1;
            Touch2.AsOld = Touch2.First;
            Touch2.Last = 2;
            Touch2.AsNew = Touch2.Last;
        })(Touch = exports.Touch || (exports.Touch = {}));
        var LinkedMap = class {
            clear() {
                this._map.clear();
                this._head = void 0;
                this._tail = void 0;
                this._size = 0;
                this._state++;
            }
            isEmpty() {
                return !this._head && !this._tail;
            }
            get size() {
                return this._size;
            }
            get first() {
                var _a;
                return (_a = this._head) === null || _a === void 0 ? void 0 : _a.value;
            }
            get last() {
                var _a;
                return (_a = this._tail) === null || _a === void 0 ? void 0 : _a.value;
            }
            has(key) {
                return this._map.has(key);
            }
            get(key, touch = Touch.None) {
                const item = this._map.get(key);
                if (!item) {
                    return void 0;
                }
                if (touch !== Touch.None) {
                    this.touch(item, touch);
                }
                return item.value;
            }
            set(key, value1, touch = Touch.None) {
                let item = this._map.get(key);
                if (item) {
                    item.value = value1;
                    if (touch !== Touch.None) {
                        this.touch(item, touch);
                    }
                } else {
                    item = {
                        key,
                        value: value1,
                        next: void 0,
                        previous: void 0
                    };
                    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 void 0;
                }
                this._map.delete(key);
                this.removeItem(item);
                this._size--;
                return item.value;
            }
            shift() {
                if (!this._head && !this._tail) {
                    return void 0;
                }
                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 map2 = this;
                const state = this._state;
                let current = this._head;
                const iterator = {
                    [Symbol.iterator] () {
                        return iterator;
                    },
                    next () {
                        if (map2._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: void 0,
                                done: true
                            };
                        }
                    }
                };
                return iterator;
            }
            values() {
                const map2 = this;
                const state = this._state;
                let current = this._head;
                const iterator = {
                    [Symbol.iterator] () {
                        return iterator;
                    },
                    next () {
                        if (map2._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: void 0,
                                done: true
                            };
                        }
                    }
                };
                return iterator;
            }
            entries() {
                const map2 = this;
                const state = this._state;
                let current = this._head;
                const iterator = {
                    [Symbol.iterator] () {
                        return iterator;
                    },
                    next () {
                        if (map2._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: void 0,
                                done: true
                            };
                        }
                    }
                };
                return iterator;
            }
            [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 = void 0;
                }
                this._state++;
            }
            addItemFirst(item) {
                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) {
                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 = void 0;
                    this._tail = void 0;
                } else if (item === this._head) {
                    if (!item.next) {
                        throw new Error("Invalid list");
                    }
                    item.next.previous = void 0;
                    this._head = item.next;
                } else if (item === this._tail) {
                    if (!item.previous) {
                        throw new Error("Invalid list");
                    }
                    item.previous.next = void 0;
                    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 = void 0;
                item.previous = void 0;
                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;
                    if (item === this._tail) {
                        previous.next = void 0;
                        this._tail = previous;
                    } else {
                        next.previous = previous;
                        previous.next = next;
                    }
                    item.previous = void 0;
                    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;
                    if (item === this._head) {
                        next.previous = void 0;
                        this._head = next;
                    } else {
                        next.previous = previous;
                        previous.next = next;
                    }
                    item.next = void 0;
                    item.previous = this._tail;
                    this._tail.next = item;
                    this._tail = item;
                    this._state++;
                }
            }
            toJSON() {
                const data = [];
                this.forEach((value1, key)=>{
                    data.push([
                        key,
                        value1
                    ]);
                });
                return data;
            }
            fromJSON(data) {
                this.clear();
                for (const [key, value1] of data){
                    this.set(key, value1);
                }
            }
            constructor(){
                this[Symbol.toStringTag] = "LinkedMap";
                this._map = /* @__PURE__ */ new Map();
                this._head = void 0;
                this._tail = void 0;
                this._size = 0;
                this._state = 0;
            }
        };
        exports.LinkedMap = LinkedMap;
        var LRUCache = class extends LinkedMap {
            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, value1) {
                super.set(key, value1, Touch.Last);
                this.checkTrim();
                return this;
            }
            checkTrim() {
                if (this.size > this._limit) {
                    this.trimOld(Math.round(this._limit * this._ratio));
                }
            }
            constructor(limit, ratio = 1){
                super();
                this._limit = limit;
                this._ratio = Math.min(Math.max(0, ratio), 1);
            }
        };
        exports.LRUCache = LRUCache;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/connection.js
var require_connection = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/connection.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.createMessageConnection = exports.ConnectionOptions = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.Trace = exports.NullLogger = exports.ProgressType = void 0;
        var ral_1 = require_ral();
        var Is = require_is();
        var messages_1 = require_messages();
        var linkedMap_1 = require_linkedMap();
        var events_1 = require_events();
        var cancellation_1 = require_cancellation();
        var CancelNotification;
        (function(CancelNotification2) {
            CancelNotification2.type = new messages_1.NotificationType("$/cancelRequest");
        })(CancelNotification || (CancelNotification = {}));
        var ProgressNotification;
        (function(ProgressNotification2) {
            ProgressNotification2.type = new messages_1.NotificationType("$/progress");
        })(ProgressNotification || (ProgressNotification = {}));
        var ProgressType = class {
            constructor(){}
        };
        exports.ProgressType = ProgressType;
        var StarRequestHandler;
        (function(StarRequestHandler2) {
            function is(value1) {
                return Is.func(value1);
            }
            StarRequestHandler2.is = is;
        })(StarRequestHandler || (StarRequestHandler = {}));
        exports.NullLogger = Object.freeze({
            error: ()=>{},
            warn: ()=>{},
            info: ()=>{},
            log: ()=>{}
        });
        var Trace;
        (function(Trace2) {
            Trace2[Trace2["Off"] = 0] = "Off";
            Trace2[Trace2["Messages"] = 1] = "Messages";
            Trace2[Trace2["Verbose"] = 2] = "Verbose";
        })(Trace = exports.Trace || (exports.Trace = {}));
        (function(Trace2) {
            function fromString(value1) {
                if (!Is.string(value1)) {
                    return Trace2.Off;
                }
                value1 = value1.toLowerCase();
                switch(value1){
                    case "off":
                        return Trace2.Off;
                    case "messages":
                        return Trace2.Messages;
                    case "verbose":
                        return Trace2.Verbose;
                    default:
                        return Trace2.Off;
                }
            }
            Trace2.fromString = fromString;
            function toString(value1) {
                switch(value1){
                    case Trace2.Off:
                        return "off";
                    case Trace2.Messages:
                        return "messages";
                    case Trace2.Verbose:
                        return "verbose";
                    default:
                        return "off";
                }
            }
            Trace2.toString = toString;
        })(Trace = exports.Trace || (exports.Trace = {}));
        var TraceFormat;
        (function(TraceFormat2) {
            TraceFormat2["Text"] = "text";
            TraceFormat2["JSON"] = "json";
        })(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}));
        (function(TraceFormat2) {
            function fromString(value1) {
                value1 = value1.toLowerCase();
                if (value1 === "json") {
                    return TraceFormat2.JSON;
                } else {
                    return TraceFormat2.Text;
                }
            }
            TraceFormat2.fromString = fromString;
        })(TraceFormat = exports.TraceFormat || (exports.TraceFormat = {}));
        var SetTraceNotification;
        (function(SetTraceNotification2) {
            SetTraceNotification2.type = new messages_1.NotificationType("$/setTrace");
        })(SetTraceNotification = exports.SetTraceNotification || (exports.SetTraceNotification = {}));
        var LogTraceNotification;
        (function(LogTraceNotification2) {
            LogTraceNotification2.type = new messages_1.NotificationType("$/logTrace");
        })(LogTraceNotification = exports.LogTraceNotification || (exports.LogTraceNotification = {}));
        var ConnectionErrors;
        (function(ConnectionErrors2) {
            ConnectionErrors2[ConnectionErrors2["Closed"] = 1] = "Closed";
            ConnectionErrors2[ConnectionErrors2["Disposed"] = 2] = "Disposed";
            ConnectionErrors2[ConnectionErrors2["AlreadyListening"] = 3] = "AlreadyListening";
        })(ConnectionErrors = exports.ConnectionErrors || (exports.ConnectionErrors = {}));
        var ConnectionError = class _ConnectionError extends Error {
            constructor(code, message){
                super(message);
                this.code = code;
                Object.setPrototypeOf(this, _ConnectionError.prototype);
            }
        };
        exports.ConnectionError = ConnectionError;
        var ConnectionStrategy;
        (function(ConnectionStrategy2) {
            function is(value1) {
                const candidate = value1;
                return candidate && Is.func(candidate.cancelUndispatched);
            }
            ConnectionStrategy2.is = is;
        })(ConnectionStrategy = exports.ConnectionStrategy || (exports.ConnectionStrategy = {}));
        var CancellationReceiverStrategy;
        (function(CancellationReceiverStrategy2) {
            CancellationReceiverStrategy2.Message = Object.freeze({
                createCancellationTokenSource (_2) {
                    return new cancellation_1.CancellationTokenSource();
                }
            });
            function is(value1) {
                const candidate = value1;
                return candidate && Is.func(candidate.createCancellationTokenSource);
            }
            CancellationReceiverStrategy2.is = is;
        })(CancellationReceiverStrategy = exports.CancellationReceiverStrategy || (exports.CancellationReceiverStrategy = {}));
        var CancellationSenderStrategy;
        (function(CancellationSenderStrategy2) {
            CancellationSenderStrategy2.Message = Object.freeze({
                sendCancellation (conn, id) {
                    conn.sendNotification(CancelNotification.type, {
                        id
                    });
                },
                cleanup (_2) {}
            });
            function is(value1) {
                const candidate = value1;
                return candidate && Is.func(candidate.sendCancellation) && Is.func(candidate.cleanup);
            }
            CancellationSenderStrategy2.is = is;
        })(CancellationSenderStrategy = exports.CancellationSenderStrategy || (exports.CancellationSenderStrategy = {}));
        var CancellationStrategy;
        (function(CancellationStrategy2) {
            CancellationStrategy2.Message = Object.freeze({
                receiver: CancellationReceiverStrategy.Message,
                sender: CancellationSenderStrategy.Message
            });
            function is(value1) {
                const candidate = value1;
                return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
            }
            CancellationStrategy2.is = is;
        })(CancellationStrategy = exports.CancellationStrategy || (exports.CancellationStrategy = {}));
        var ConnectionOptions;
        (function(ConnectionOptions2) {
            function is(value1) {
                const candidate = value1;
                return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy));
            }
            ConnectionOptions2.is = is;
        })(ConnectionOptions = exports.ConnectionOptions || (exports.ConnectionOptions = {}));
        var ConnectionState;
        (function(ConnectionState2) {
            ConnectionState2[ConnectionState2["New"] = 1] = "New";
            ConnectionState2[ConnectionState2["Listening"] = 2] = "Listening";
            ConnectionState2[ConnectionState2["Closed"] = 3] = "Closed";
            ConnectionState2[ConnectionState2["Disposed"] = 4] = "Disposed";
        })(ConnectionState || (ConnectionState = {}));
        function createMessageConnection(messageReader, messageWriter, _logger, options) {
            const logger = _logger !== void 0 ? _logger : exports.NullLogger;
            let sequenceNumber = 0;
            let notificationSquenceNumber = 0;
            let unknownResponseSquenceNumber = 0;
            const version = "2.0";
            let starRequestHandler = void 0;
            const requestHandlers = /* @__PURE__ */ Object.create(null);
            let starNotificationHandler = void 0;
            const notificationHandlers = /* @__PURE__ */ Object.create(null);
            const progressHandlers = /* @__PURE__ */ new Map();
            let timer;
            let messageQueue = new linkedMap_1.LinkedMap();
            let responsePromises = /* @__PURE__ */ Object.create(null);
            let requestTokens = /* @__PURE__ */ Object.create(null);
            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-" + (++unknownResponseSquenceNumber).toString();
                } else {
                    return "res-" + id.toString();
                }
            }
            function createNotificationQueueKey() {
                return "not-" + (++notificationSquenceNumber).toString();
            }
            function addMessageToQueue(queue, message) {
                if (messages_1.isRequestMessage(message)) {
                    queue.set(createRequestQueueKey(message.id), message);
                } else if (messages_1.isResponseMessage(message)) {
                    queue.set(createResponseQueueKey(message.id), message);
                } else {
                    queue.set(createNotificationQueueKey(), message);
                }
            }
            function cancelUndispatched(_message) {
                return void 0;
            }
            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(void 0);
                }
            }
            function readErrorHandler(error) {
                errorEmitter.fire([
                    error,
                    void 0,
                    void 0
                ]);
            }
            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 = ral_1.default().timer.setImmediate(()=>{
                    timer = void 0;
                    processMessageQueue();
                });
            }
            function processMessageQueue() {
                if (messageQueue.size === 0) {
                    return;
                }
                const message = messageQueue.shift();
                try {
                    if (messages_1.isRequestMessage(message)) {
                        handleRequest(message);
                    } else if (messages_1.isNotificationMessage(message)) {
                        handleNotification(message);
                    } else if (messages_1.isResponseMessage(message)) {
                        handleResponse(message);
                    } else {
                        handleInvalidMessage(message);
                    }
                } finally{
                    triggerMessageQueue();
                }
            }
            const callback = (message)=>{
                try {
                    if (messages_1.isNotificationMessage(message) && message.method === CancelNotification.type.method) {
                        const key = createRequestQueueKey(message.params.id);
                        const toCancel = messageQueue.get(key);
                        if (messages_1.isRequestMessage(toCancel)) {
                            const strategy = options === null || options === void 0 ? void 0 : options.connectionStrategy;
                            const response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
                            if (response && (response.error !== void 0 || response.result !== void 0)) {
                                messageQueue.delete(key);
                                response.id = toCancel.id;
                                traceSendingResponse(response, message.method, Date.now());
                                messageWriter.write(response);
                                return;
                            }
                        }
                    }
                    addMessageToQueue(messageQueue, message);
                } finally{
                    triggerMessageQueue();
                }
            };
            function handleRequest(requestMessage) {
                if (isDisposed()) {
                    return;
                }
                function reply(resultOrError, method, startTime2) {
                    const message = {
                        jsonrpc: version,
                        id: requestMessage.id
                    };
                    if (resultOrError instanceof messages_1.ResponseError) {
                        message.error = resultOrError.toJson();
                    } else {
                        message.result = resultOrError === void 0 ? null : resultOrError;
                    }
                    traceSendingResponse(message, method, startTime2);
                    messageWriter.write(message);
                }
                function replyError(error, method, startTime2) {
                    const message = {
                        jsonrpc: version,
                        id: requestMessage.id,
                        error: error.toJson()
                    };
                    traceSendingResponse(message, method, startTime2);
                    messageWriter.write(message);
                }
                function replySuccess(result, method, startTime2) {
                    if (result === void 0) {
                        result = null;
                    }
                    const message = {
                        jsonrpc: version,
                        id: requestMessage.id,
                        result
                    };
                    traceSendingResponse(message, method, startTime2);
                    messageWriter.write(message);
                }
                traceReceivedRequest(requestMessage);
                const element = requestHandlers[requestMessage.method];
                let type;
                let requestHandler;
                if (element) {
                    type = element.type;
                    requestHandler = element.handler;
                }
                const startTime = Date.now();
                if (requestHandler || starRequestHandler) {
                    const tokenKey = String(requestMessage.id);
                    const cancellationSource = cancellationStrategy.receiver.createCancellationTokenSource(tokenKey);
                    requestTokens[tokenKey] = cancellationSource;
                    try {
                        let handlerResult;
                        if (requestHandler) {
                            if (requestMessage.params === void 0) {
                                if (type !== void 0 && type.numberOfParams !== 0) {
                                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but recevied none.`), requestMessage.method, startTime);
                                    return;
                                }
                                handlerResult = requestHandler(cancellationSource.token);
                            } else if (Array.isArray(requestMessage.params)) {
                                if (type !== void 0 && 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 !== void 0 && 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) {
                            delete requestTokens[tokenKey];
                            replySuccess(handlerResult, requestMessage.method, startTime);
                        } else if (promise.then) {
                            promise.then((resultOrError)=>{
                                delete requestTokens[tokenKey];
                                reply(resultOrError, requestMessage.method, startTime);
                            }, (error)=>{
                                delete requestTokens[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 {
                            delete requestTokens[tokenKey];
                            reply(handlerResult, requestMessage.method, startTime);
                        }
                    } catch (error) {
                        delete requestTokens[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()) {
                    return;
                }
                if (responseMessage.id === null) {
                    if (responseMessage.error) {
                        logger.error(`Received response message without id: Error is: 
${JSON.stringify(responseMessage.error, void 0, 4)}`);
                    } else {
                        logger.error(`Received response message without id. No further error information provided.`);
                    }
                } else {
                    const key = String(responseMessage.id);
                    const responsePromise = responsePromises[key];
                    traceReceivedResponse(responseMessage, responsePromise);
                    if (responsePromise) {
                        delete responsePromises[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 !== void 0) {
                                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()) {
                    return;
                }
                let type = void 0;
                let notificationHandler;
                if (message.method === CancelNotification.type.method) {
                    notificationHandler = (params)=>{
                        const id = params.id;
                        const source = requestTokens[String(id)];
                        if (source) {
                            source.cancel();
                        }
                    };
                } else {
                    const element = notificationHandlers[message.method];
                    if (element) {
                        notificationHandler = element.handler;
                        type = element.type;
                    }
                }
                if (notificationHandler || starNotificationHandler) {
                    try {
                        traceReceivedNotification(message);
                        if (notificationHandler) {
                            if (message.params === void 0) {
                                if (type !== void 0) {
                                    if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) {
                                        logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but recevied none.`);
                                    }
                                }
                                notificationHandler();
                            } else if (Array.isArray(message.params)) {
                                if (type !== void 0) {
                                    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 ${message.params.length} argumennts`);
                                    }
                                }
                                notificationHandler(...message.params);
                            } else {
                                if (type !== void 0 && 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:
${JSON.stringify(message, null, 4)}`);
                const responseMessage = message;
                if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {
                    const key = String(responseMessage.id);
                    const responseHandler = responsePromises[key];
                    if (responseHandler) {
                        responseHandler.reject(new Error("The received response has neither a result nor an error property."));
                    }
                }
            }
            function traceSendingRequest(message) {
                if (trace === Trace.Off || !tracer) {
                    return;
                }
                if (traceFormat === TraceFormat.Text) {
                    let data = void 0;
                    if (trace === Trace.Verbose && message.params) {
                        data = `Params: ${JSON.stringify(message.params, null, 4)}

`;
                    }
                    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 = void 0;
                    if (trace === Trace.Verbose) {
                        if (message.params) {
                            data = `Params: ${JSON.stringify(message.params, null, 4)}

`;
                        } 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 = void 0;
                    if (trace === Trace.Verbose) {
                        if (message.error && message.error.data) {
                            data = `Error data: ${JSON.stringify(message.error.data, null, 4)}

`;
                        } else {
                            if (message.result) {
                                data = `Result: ${JSON.stringify(message.result, null, 4)}

`;
                            } else if (message.error === void 0) {
                                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 = void 0;
                    if (trace === Trace.Verbose && message.params) {
                        data = `Params: ${JSON.stringify(message.params, null, 4)}

`;
                    }
                    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 = void 0;
                    if (trace === Trace.Verbose) {
                        if (message.params) {
                            data = `Params: ${JSON.stringify(message.params, null, 4)}

`;
                        } 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 = void 0;
                    if (trace === Trace.Verbose) {
                        if (message.error && message.error.data) {
                            data = `Error data: ${JSON.stringify(message.error.data, null, 4)}

`;
                        } else {
                            if (message.result) {
                                data = `Result: ${JSON.stringify(message.result, null, 4)}

`;
                            } else if (message.error === void 0) {
                                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 === void 0) {
                    return null;
                } else {
                    return param;
                }
            }
            function nullToUndefined(param) {
                if (param === null) {
                    return void 0;
                } else {
                    return param;
                }
            }
            function isNamedParam(param) {
                return param !== void 0 && 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)
                            ];
                        }
                        break;
                    case messages_1.ParameterStructures.byName:
                        if (!isNamedParam(param)) {
                            throw new Error(`Recevied 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 = void 0;
                        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 = void 0;
                                break;
                            case 1:
                                messageParams = computeSingleParam(parameterStructures, args[paramStart]);
                                break;
                            default:
                                if (parameterStructures === messages_1.ParameterStructures.byName) {
                                    throw new Error(`Recevied ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
                                }
                                messageParams = args.slice(paramStart, paramEnd).map((value1)=>undefinedToNull(value1));
                                break;
                        }
                    } else {
                        const params = args;
                        method = type.method;
                        messageParams = computeMessageParams(type, params);
                    }
                    const notificationMessage = {
                        jsonrpc: version,
                        method,
                        params: messageParams
                    };
                    traceSendingNotification(notificationMessage);
                    messageWriter.write(notificationMessage);
                },
                onNotification: (type, handler)=>{
                    throwIfClosedOrDisposed();
                    let method;
                    if (Is.func(type)) {
                        starNotificationHandler = type;
                    } else if (handler) {
                        if (Is.string(type)) {
                            method = type;
                            notificationHandlers[type] = {
                                type: void 0,
                                handler
                            };
                        } else {
                            method = type.method;
                            notificationHandlers[type.method] = {
                                type,
                                handler
                            };
                        }
                    }
                    return {
                        dispose: ()=>{
                            if (method !== void 0) {
                                delete notificationHandlers[method];
                            } else {
                                starNotificationHandler = void 0;
                            }
                        }
                    };
                },
                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, value1)=>{
                    connection.sendNotification(ProgressNotification.type, {
                        token,
                        value: value1
                    });
                },
                onUnhandledProgress: unhandledProgressEmitter.event,
                sendRequest: (type, ...args)=>{
                    throwIfClosedOrDisposed();
                    throwIfNotListening();
                    let method;
                    let messageParams;
                    let token = void 0;
                    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 = void 0;
                                break;
                            case 1:
                                messageParams = computeSingleParam(parameterStructures, args[paramStart]);
                                break;
                            default:
                                if (parameterStructures === messages_1.ParameterStructures.byName) {
                                    throw new Error(`Recevied ${numberOfParams} parameters for 'by Name' request parameter structure.`);
                                }
                                messageParams = args.slice(paramStart, paramEnd).map((value1)=>undefinedToNull(value1));
                                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] : void 0;
                    }
                    const id = sequenceNumber++;
                    let disposable;
                    if (token) {
                        disposable = token.onCancellationRequested(()=>{
                            cancellationStrategy.sender.sendCancellation(connection, id);
                        });
                    }
                    const result = new Promise((resolve2, reject)=>{
                        const requestMessage = {
                            jsonrpc: version,
                            id,
                            method,
                            params: messageParams
                        };
                        const resolveWithCleanup = (r)=>{
                            resolve2(r);
                            cancellationStrategy.sender.cleanup(id);
                            disposable === null || disposable === void 0 ? void 0 : disposable.dispose();
                        };
                        const rejectWithCleanup = (r)=>{
                            reject(r);
                            cancellationStrategy.sender.cleanup(id);
                            disposable === null || disposable === void 0 ? void 0 : disposable.dispose();
                        };
                        let responsePromise = {
                            method,
                            timerStart: Date.now(),
                            resolve: resolveWithCleanup,
                            reject: rejectWithCleanup
                        };
                        traceSendingRequest(requestMessage);
                        try {
                            messageWriter.write(requestMessage);
                        } catch (e) {
                            responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, e.message ? e.message : "Unknown reason"));
                            responsePromise = null;
                        }
                        if (responsePromise) {
                            responsePromises[String(id)] = responsePromise;
                        }
                    });
                    return result;
                },
                onRequest: (type, handler)=>{
                    throwIfClosedOrDisposed();
                    let method = null;
                    if (StarRequestHandler.is(type)) {
                        method = void 0;
                        starRequestHandler = type;
                    } else if (Is.string(type)) {
                        method = null;
                        if (handler !== void 0) {
                            method = type;
                            requestHandlers[type] = {
                                handler,
                                type: void 0
                            };
                        }
                    } else {
                        if (handler !== void 0) {
                            method = type.method;
                            requestHandlers[type.method] = {
                                type,
                                handler
                            };
                        }
                    }
                    return {
                        dispose: ()=>{
                            if (method === null) {
                                return;
                            }
                            if (method !== void 0) {
                                delete requestHandlers[method];
                            } else {
                                starRequestHandler = void 0;
                            }
                        }
                    };
                },
                trace: (_value, _tracer, sendNotificationOrTraceOptions)=>{
                    let _sendNotification = false;
                    let _traceFormat = TraceFormat.Text;
                    if (sendNotificationOrTraceOptions !== void 0) {
                        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 = void 0;
                    } else {
                        tracer = _tracer;
                    }
                    if (_sendNotification && !isClosed() && !isDisposed()) {
                        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(void 0);
                    const error = new Error("Connection got disposed.");
                    Object.keys(responsePromises).forEach((key)=>{
                        responsePromises[key].reject(error);
                    });
                    responsePromises = /* @__PURE__ */ Object.create(null);
                    requestTokens = /* @__PURE__ */ Object.create(null);
                    messageQueue = new linkedMap_1.LinkedMap();
                    if (Is.func(messageWriter.dispose)) {
                        messageWriter.dispose();
                    }
                    if (Is.func(messageReader.dispose)) {
                        messageReader.dispose();
                    }
                },
                listen: ()=>{
                    throwIfClosedOrDisposed();
                    throwIfListening();
                    state = ConnectionState.Listening;
                    messageReader.listen(callback);
                },
                inspect: ()=>{
                    ral_1.default().console.log("inspect");
                }
            };
            connection.onNotification(LogTraceNotification.type, (params)=>{
                if (trace === Trace.Off || !tracer) {
                    return;
                }
                tracer.log(params.message, trace === Trace.Verbose ? params.verbose : void 0);
            });
            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;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/api.js
var require_api = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/common/api.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.Trace = exports.ProgressType = exports.createMessageConnection = exports.NullLogger = exports.ConnectionOptions = exports.ConnectionStrategy = exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = exports.CancellationToken = exports.CancellationTokenSource = exports.Emitter = exports.Event = exports.Disposable = 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.RAL = void 0;
        exports.CancellationStrategy = void 0;
        var messages_1 = require_messages();
        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;
            }
        });
        var disposable_1 = require_disposable();
        Object.defineProperty(exports, "Disposable", {
            enumerable: true,
            get: function() {
                return disposable_1.Disposable;
            }
        });
        var events_1 = require_events();
        Object.defineProperty(exports, "Event", {
            enumerable: true,
            get: function() {
                return events_1.Event;
            }
        });
        Object.defineProperty(exports, "Emitter", {
            enumerable: true,
            get: function() {
                return events_1.Emitter;
            }
        });
        var cancellation_1 = require_cancellation();
        Object.defineProperty(exports, "CancellationTokenSource", {
            enumerable: true,
            get: function() {
                return cancellation_1.CancellationTokenSource;
            }
        });
        Object.defineProperty(exports, "CancellationToken", {
            enumerable: true,
            get: function() {
                return cancellation_1.CancellationToken;
            }
        });
        var messageReader_1 = require_messageReader();
        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;
            }
        });
        var messageWriter_1 = require_messageWriter();
        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;
            }
        });
        var connection_1 = require_connection();
        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, "ProgressType", {
            enumerable: true,
            get: function() {
                return connection_1.ProgressType;
            }
        });
        Object.defineProperty(exports, "Trace", {
            enumerable: true,
            get: function() {
                return connection_1.Trace;
            }
        });
        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;
            }
        });
        var ral_1 = require_ral();
        exports.RAL = ral_1.default;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/browser/main.js
var require_main2 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/lib/browser/main.js" (exports) {
        "use strict";
        var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
            if (k2 === void 0) k2 = k;
            Object.defineProperty(o, k2, {
                enumerable: true,
                get: function() {
                    return m[k];
                }
            });
        } : function(o, m, k, k2) {
            if (k2 === void 0) k2 = k;
            o[k2] = m[k];
        });
        var __exportStar = exports && exports.__exportStar || function(m, exports2) {
            for(var p in m)if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
        };
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.createMessageConnection = exports.BrowserMessageWriter = exports.BrowserMessageReader = void 0;
        var ril_1 = require_ril();
        ril_1.default.install();
        var api_1 = require_api();
        __exportStar(require_api(), exports);
        var BrowserMessageReader = class extends api_1.AbstractMessageReader {
            listen(callback) {
                return this._onData.event(callback);
            }
            constructor(context){
                super();
                this._onData = new api_1.Emitter();
                this._messageListener = (event)=>{
                    this._onData.fire(event.data);
                };
                context.addEventListener("error", (event)=>this.fireError(event));
                context.onmessage = this._messageListener;
            }
        };
        exports.BrowserMessageReader = BrowserMessageReader;
        var BrowserMessageWriter = class extends api_1.AbstractMessageWriter {
            write(msg) {
                try {
                    this.context.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() {}
            constructor(context){
                super();
                this.context = context;
                this.errorCount = 0;
                context.addEventListener("error", (event)=>this.fireError(event));
            }
        };
        exports.BrowserMessageWriter = BrowserMessageWriter;
        function createMessageConnection(reader, writer, logger, options) {
            if (logger === void 0) {
                logger = api_1.NullLogger;
            }
            if (api_1.ConnectionStrategy.is(options)) {
                options = {
                    connectionStrategy: options
                };
            }
            return api_1.createMessageConnection(reader, writer, logger, options);
        }
        exports.createMessageConnection = createMessageConnection;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/browser.js
var require_browser = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-jsonrpc/browser.js" (exports, module) {
        "use strict";
        module.exports = require_main2();
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/messages.js
var require_messages2 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/messages.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.ProtocolNotificationType = exports.ProtocolNotificationType0 = exports.ProtocolRequestType = exports.ProtocolRequestType0 = exports.RegistrationType = void 0;
        var vscode_jsonrpc_1 = require_main2();
        var RegistrationType = class {
            constructor(method){
                this.method = method;
            }
        };
        exports.RegistrationType = RegistrationType;
        var ProtocolRequestType0 = class extends vscode_jsonrpc_1.RequestType0 {
            constructor(method){
                super(method);
            }
        };
        exports.ProtocolRequestType0 = ProtocolRequestType0;
        var ProtocolRequestType = class extends vscode_jsonrpc_1.RequestType {
            constructor(method){
                super(method, vscode_jsonrpc_1.ParameterStructures.byName);
            }
        };
        exports.ProtocolRequestType = ProtocolRequestType;
        var ProtocolNotificationType0 = class extends vscode_jsonrpc_1.NotificationType0 {
            constructor(method){
                super(method);
            }
        };
        exports.ProtocolNotificationType0 = ProtocolNotificationType0;
        var ProtocolNotificationType = class extends vscode_jsonrpc_1.NotificationType {
            constructor(method){
                super(method, vscode_jsonrpc_1.ParameterStructures.byName);
            }
        };
        exports.ProtocolNotificationType = ProtocolNotificationType;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/utils/is.js
var require_is2 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/utils/is.js" (exports) {
        "use strict";
        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(value1) {
            return value1 === true || value1 === false;
        }
        exports.boolean = boolean;
        function string2(value1) {
            return typeof value1 === "string" || value1 instanceof String;
        }
        exports.string = string2;
        function number(value1) {
            return typeof value1 === "number" || value1 instanceof Number;
        }
        exports.number = number;
        function error(value1) {
            return value1 instanceof Error;
        }
        exports.error = error;
        function func(value1) {
            return typeof value1 === "function";
        }
        exports.func = func;
        function array(value1) {
            return Array.isArray(value1);
        }
        exports.array = array;
        function stringArray(value1) {
            return array(value1) && value1.every((elem)=>string2(elem));
        }
        exports.stringArray = stringArray;
        function typedArray(value1, check) {
            return Array.isArray(value1) && value1.every(check);
        }
        exports.typedArray = typedArray;
        function objectLiteral(value1) {
            return value1 !== null && typeof value1 === "object";
        }
        exports.objectLiteral = objectLiteral;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js
var require_protocol_implementation = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.ImplementationRequest = void 0;
        var messages_1 = require_messages2();
        var ImplementationRequest;
        (function(ImplementationRequest2) {
            ImplementationRequest2.method = "textDocument/implementation";
            ImplementationRequest2.type = new messages_1.ProtocolRequestType(ImplementationRequest2.method);
        })(ImplementationRequest = exports.ImplementationRequest || (exports.ImplementationRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js
var require_protocol_typeDefinition = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.TypeDefinitionRequest = void 0;
        var messages_1 = require_messages2();
        var TypeDefinitionRequest;
        (function(TypeDefinitionRequest2) {
            TypeDefinitionRequest2.method = "textDocument/typeDefinition";
            TypeDefinitionRequest2.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest2.method);
        })(TypeDefinitionRequest = exports.TypeDefinitionRequest || (exports.TypeDefinitionRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolders.js
var require_protocol_workspaceFolders = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolders.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = void 0;
        var messages_1 = require_messages2();
        var WorkspaceFoldersRequest;
        (function(WorkspaceFoldersRequest2) {
            WorkspaceFoldersRequest2.type = new messages_1.ProtocolRequestType0("workspace/workspaceFolders");
        })(WorkspaceFoldersRequest = exports.WorkspaceFoldersRequest || (exports.WorkspaceFoldersRequest = {}));
        var DidChangeWorkspaceFoldersNotification;
        (function(DidChangeWorkspaceFoldersNotification2) {
            DidChangeWorkspaceFoldersNotification2.type = new messages_1.ProtocolNotificationType("workspace/didChangeWorkspaceFolders");
        })(DidChangeWorkspaceFoldersNotification = exports.DidChangeWorkspaceFoldersNotification || (exports.DidChangeWorkspaceFoldersNotification = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js
var require_protocol_configuration = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.ConfigurationRequest = void 0;
        var messages_1 = require_messages2();
        var ConfigurationRequest;
        (function(ConfigurationRequest2) {
            ConfigurationRequest2.type = new messages_1.ProtocolRequestType("workspace/configuration");
        })(ConfigurationRequest = exports.ConfigurationRequest || (exports.ConfigurationRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js
var require_protocol_colorProvider = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.ColorPresentationRequest = exports.DocumentColorRequest = void 0;
        var messages_1 = require_messages2();
        var DocumentColorRequest;
        (function(DocumentColorRequest2) {
            DocumentColorRequest2.method = "textDocument/documentColor";
            DocumentColorRequest2.type = new messages_1.ProtocolRequestType(DocumentColorRequest2.method);
        })(DocumentColorRequest = exports.DocumentColorRequest || (exports.DocumentColorRequest = {}));
        var ColorPresentationRequest;
        (function(ColorPresentationRequest2) {
            ColorPresentationRequest2.type = new messages_1.ProtocolRequestType("textDocument/colorPresentation");
        })(ColorPresentationRequest = exports.ColorPresentationRequest || (exports.ColorPresentationRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js
var require_protocol_foldingRange = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.FoldingRangeRequest = exports.FoldingRangeKind = void 0;
        var messages_1 = require_messages2();
        var FoldingRangeKind2;
        (function(FoldingRangeKind3) {
            FoldingRangeKind3["Comment"] = "comment";
            FoldingRangeKind3["Imports"] = "imports";
            FoldingRangeKind3["Region"] = "region";
        })(FoldingRangeKind2 = exports.FoldingRangeKind || (exports.FoldingRangeKind = {}));
        var FoldingRangeRequest;
        (function(FoldingRangeRequest2) {
            FoldingRangeRequest2.method = "textDocument/foldingRange";
            FoldingRangeRequest2.type = new messages_1.ProtocolRequestType(FoldingRangeRequest2.method);
        })(FoldingRangeRequest = exports.FoldingRangeRequest || (exports.FoldingRangeRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js
var require_protocol_declaration = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.DeclarationRequest = void 0;
        var messages_1 = require_messages2();
        var DeclarationRequest;
        (function(DeclarationRequest2) {
            DeclarationRequest2.method = "textDocument/declaration";
            DeclarationRequest2.type = new messages_1.ProtocolRequestType(DeclarationRequest2.method);
        })(DeclarationRequest = exports.DeclarationRequest || (exports.DeclarationRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js
var require_protocol_selectionRange = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.SelectionRangeRequest = void 0;
        var messages_1 = require_messages2();
        var SelectionRangeRequest;
        (function(SelectionRangeRequest2) {
            SelectionRangeRequest2.method = "textDocument/selectionRange";
            SelectionRangeRequest2.type = new messages_1.ProtocolRequestType(SelectionRangeRequest2.method);
        })(SelectionRangeRequest = exports.SelectionRangeRequest || (exports.SelectionRangeRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js
var require_protocol_progress = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = void 0;
        var vscode_jsonrpc_1 = require_main2();
        var messages_1 = require_messages2();
        var WorkDoneProgress;
        (function(WorkDoneProgress2) {
            WorkDoneProgress2.type = new vscode_jsonrpc_1.ProgressType();
            function is(value1) {
                return value1 === WorkDoneProgress2.type;
            }
            WorkDoneProgress2.is = is;
        })(WorkDoneProgress = exports.WorkDoneProgress || (exports.WorkDoneProgress = {}));
        var WorkDoneProgressCreateRequest;
        (function(WorkDoneProgressCreateRequest2) {
            WorkDoneProgressCreateRequest2.type = new messages_1.ProtocolRequestType("window/workDoneProgress/create");
        })(WorkDoneProgressCreateRequest = exports.WorkDoneProgressCreateRequest || (exports.WorkDoneProgressCreateRequest = {}));
        var WorkDoneProgressCancelNotification;
        (function(WorkDoneProgressCancelNotification2) {
            WorkDoneProgressCancelNotification2.type = new messages_1.ProtocolNotificationType("window/workDoneProgress/cancel");
        })(WorkDoneProgressCancelNotification = exports.WorkDoneProgressCancelNotification || (exports.WorkDoneProgressCancelNotification = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js
var require_protocol_callHierarchy = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.CallHierarchyPrepareRequest = void 0;
        var messages_1 = require_messages2();
        var CallHierarchyPrepareRequest;
        (function(CallHierarchyPrepareRequest2) {
            CallHierarchyPrepareRequest2.method = "textDocument/prepareCallHierarchy";
            CallHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest2.method);
        })(CallHierarchyPrepareRequest = exports.CallHierarchyPrepareRequest || (exports.CallHierarchyPrepareRequest = {}));
        var CallHierarchyIncomingCallsRequest;
        (function(CallHierarchyIncomingCallsRequest2) {
            CallHierarchyIncomingCallsRequest2.method = "callHierarchy/incomingCalls";
            CallHierarchyIncomingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest2.method);
        })(CallHierarchyIncomingCallsRequest = exports.CallHierarchyIncomingCallsRequest || (exports.CallHierarchyIncomingCallsRequest = {}));
        var CallHierarchyOutgoingCallsRequest;
        (function(CallHierarchyOutgoingCallsRequest2) {
            CallHierarchyOutgoingCallsRequest2.method = "callHierarchy/outgoingCalls";
            CallHierarchyOutgoingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest2.method);
        })(CallHierarchyOutgoingCallsRequest = exports.CallHierarchyOutgoingCallsRequest || (exports.CallHierarchyOutgoingCallsRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js
var require_protocol_semanticTokens = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.SemanticTokensRegistrationType = exports.TokenFormat = exports.SemanticTokens = exports.SemanticTokenModifiers = exports.SemanticTokenTypes = void 0;
        var messages_1 = require_messages2();
        var SemanticTokenTypes;
        (function(SemanticTokenTypes2) {
            SemanticTokenTypes2["namespace"] = "namespace";
            SemanticTokenTypes2["type"] = "type";
            SemanticTokenTypes2["class"] = "class";
            SemanticTokenTypes2["enum"] = "enum";
            SemanticTokenTypes2["interface"] = "interface";
            SemanticTokenTypes2["struct"] = "struct";
            SemanticTokenTypes2["typeParameter"] = "typeParameter";
            SemanticTokenTypes2["parameter"] = "parameter";
            SemanticTokenTypes2["variable"] = "variable";
            SemanticTokenTypes2["property"] = "property";
            SemanticTokenTypes2["enumMember"] = "enumMember";
            SemanticTokenTypes2["event"] = "event";
            SemanticTokenTypes2["function"] = "function";
            SemanticTokenTypes2["method"] = "method";
            SemanticTokenTypes2["macro"] = "macro";
            SemanticTokenTypes2["keyword"] = "keyword";
            SemanticTokenTypes2["modifier"] = "modifier";
            SemanticTokenTypes2["comment"] = "comment";
            SemanticTokenTypes2["string"] = "string";
            SemanticTokenTypes2["number"] = "number";
            SemanticTokenTypes2["regexp"] = "regexp";
            SemanticTokenTypes2["operator"] = "operator";
        })(SemanticTokenTypes = exports.SemanticTokenTypes || (exports.SemanticTokenTypes = {}));
        var SemanticTokenModifiers;
        (function(SemanticTokenModifiers2) {
            SemanticTokenModifiers2["declaration"] = "declaration";
            SemanticTokenModifiers2["definition"] = "definition";
            SemanticTokenModifiers2["readonly"] = "readonly";
            SemanticTokenModifiers2["static"] = "static";
            SemanticTokenModifiers2["deprecated"] = "deprecated";
            SemanticTokenModifiers2["abstract"] = "abstract";
            SemanticTokenModifiers2["async"] = "async";
            SemanticTokenModifiers2["modification"] = "modification";
            SemanticTokenModifiers2["documentation"] = "documentation";
            SemanticTokenModifiers2["defaultLibrary"] = "defaultLibrary";
        })(SemanticTokenModifiers = exports.SemanticTokenModifiers || (exports.SemanticTokenModifiers = {}));
        var SemanticTokens;
        (function(SemanticTokens2) {
            function is(value1) {
                const candidate = value1;
                return candidate !== void 0 && (candidate.resultId === void 0 || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
            }
            SemanticTokens2.is = is;
        })(SemanticTokens = exports.SemanticTokens || (exports.SemanticTokens = {}));
        var TokenFormat;
        (function(TokenFormat2) {
            TokenFormat2.Relative = "relative";
        })(TokenFormat = exports.TokenFormat || (exports.TokenFormat = {}));
        var SemanticTokensRegistrationType;
        (function(SemanticTokensRegistrationType2) {
            SemanticTokensRegistrationType2.method = "textDocument/semanticTokens";
            SemanticTokensRegistrationType2.type = new messages_1.RegistrationType(SemanticTokensRegistrationType2.method);
        })(SemanticTokensRegistrationType = exports.SemanticTokensRegistrationType || (exports.SemanticTokensRegistrationType = {}));
        var SemanticTokensRequest;
        (function(SemanticTokensRequest2) {
            SemanticTokensRequest2.method = "textDocument/semanticTokens/full";
            SemanticTokensRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRequest2.method);
        })(SemanticTokensRequest = exports.SemanticTokensRequest || (exports.SemanticTokensRequest = {}));
        var SemanticTokensDeltaRequest;
        (function(SemanticTokensDeltaRequest2) {
            SemanticTokensDeltaRequest2.method = "textDocument/semanticTokens/full/delta";
            SemanticTokensDeltaRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensDeltaRequest2.method);
        })(SemanticTokensDeltaRequest = exports.SemanticTokensDeltaRequest || (exports.SemanticTokensDeltaRequest = {}));
        var SemanticTokensRangeRequest;
        (function(SemanticTokensRangeRequest2) {
            SemanticTokensRangeRequest2.method = "textDocument/semanticTokens/range";
            SemanticTokensRangeRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest2.method);
        })(SemanticTokensRangeRequest = exports.SemanticTokensRangeRequest || (exports.SemanticTokensRangeRequest = {}));
        var SemanticTokensRefreshRequest;
        (function(SemanticTokensRefreshRequest2) {
            SemanticTokensRefreshRequest2.method = `workspace/semanticTokens/refresh`;
            SemanticTokensRefreshRequest2.type = new messages_1.ProtocolRequestType0(SemanticTokensRefreshRequest2.method);
        })(SemanticTokensRefreshRequest = exports.SemanticTokensRefreshRequest || (exports.SemanticTokensRefreshRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js
var require_protocol_showDocument = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.ShowDocumentRequest = void 0;
        var messages_1 = require_messages2();
        var ShowDocumentRequest;
        (function(ShowDocumentRequest2) {
            ShowDocumentRequest2.method = "window/showDocument";
            ShowDocumentRequest2.type = new messages_1.ProtocolRequestType(ShowDocumentRequest2.method);
        })(ShowDocumentRequest = exports.ShowDocumentRequest || (exports.ShowDocumentRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js
var require_protocol_linkedEditingRange = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.LinkedEditingRangeRequest = void 0;
        var messages_1 = require_messages2();
        var LinkedEditingRangeRequest;
        (function(LinkedEditingRangeRequest2) {
            LinkedEditingRangeRequest2.method = "textDocument/linkedEditingRange";
            LinkedEditingRangeRequest2.type = new messages_1.ProtocolRequestType(LinkedEditingRangeRequest2.method);
        })(LinkedEditingRangeRequest = exports.LinkedEditingRangeRequest || (exports.LinkedEditingRangeRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js
var require_protocol_fileOperations = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.DidRenameFilesNotification = exports.WillRenameFilesRequest = exports.DidCreateFilesNotification = exports.WillCreateFilesRequest = exports.FileOperationPatternKind = void 0;
        var messages_1 = require_messages2();
        var FileOperationPatternKind;
        (function(FileOperationPatternKind2) {
            FileOperationPatternKind2.file = "file";
            FileOperationPatternKind2.folder = "folder";
        })(FileOperationPatternKind = exports.FileOperationPatternKind || (exports.FileOperationPatternKind = {}));
        var WillCreateFilesRequest;
        (function(WillCreateFilesRequest2) {
            WillCreateFilesRequest2.method = "workspace/willCreateFiles";
            WillCreateFilesRequest2.type = new messages_1.ProtocolRequestType(WillCreateFilesRequest2.method);
        })(WillCreateFilesRequest = exports.WillCreateFilesRequest || (exports.WillCreateFilesRequest = {}));
        var DidCreateFilesNotification;
        (function(DidCreateFilesNotification2) {
            DidCreateFilesNotification2.method = "workspace/didCreateFiles";
            DidCreateFilesNotification2.type = new messages_1.ProtocolNotificationType(DidCreateFilesNotification2.method);
        })(DidCreateFilesNotification = exports.DidCreateFilesNotification || (exports.DidCreateFilesNotification = {}));
        var WillRenameFilesRequest;
        (function(WillRenameFilesRequest2) {
            WillRenameFilesRequest2.method = "workspace/willRenameFiles";
            WillRenameFilesRequest2.type = new messages_1.ProtocolRequestType(WillRenameFilesRequest2.method);
        })(WillRenameFilesRequest = exports.WillRenameFilesRequest || (exports.WillRenameFilesRequest = {}));
        var DidRenameFilesNotification;
        (function(DidRenameFilesNotification2) {
            DidRenameFilesNotification2.method = "workspace/didRenameFiles";
            DidRenameFilesNotification2.type = new messages_1.ProtocolNotificationType(DidRenameFilesNotification2.method);
        })(DidRenameFilesNotification = exports.DidRenameFilesNotification || (exports.DidRenameFilesNotification = {}));
        var DidDeleteFilesNotification;
        (function(DidDeleteFilesNotification2) {
            DidDeleteFilesNotification2.method = "workspace/didDeleteFiles";
            DidDeleteFilesNotification2.type = new messages_1.ProtocolNotificationType(DidDeleteFilesNotification2.method);
        })(DidDeleteFilesNotification = exports.DidDeleteFilesNotification || (exports.DidDeleteFilesNotification = {}));
        var WillDeleteFilesRequest;
        (function(WillDeleteFilesRequest2) {
            WillDeleteFilesRequest2.method = "workspace/willDeleteFiles";
            WillDeleteFilesRequest2.type = new messages_1.ProtocolRequestType(WillDeleteFilesRequest2.method);
        })(WillDeleteFilesRequest = exports.WillDeleteFilesRequest || (exports.WillDeleteFilesRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js
var require_protocol_moniker = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = void 0;
        var messages_1 = require_messages2();
        var UniquenessLevel;
        (function(UniquenessLevel2) {
            UniquenessLevel2["document"] = "document";
            UniquenessLevel2["project"] = "project";
            UniquenessLevel2["group"] = "group";
            UniquenessLevel2["scheme"] = "scheme";
            UniquenessLevel2["global"] = "global";
        })(UniquenessLevel = exports.UniquenessLevel || (exports.UniquenessLevel = {}));
        var MonikerKind;
        (function(MonikerKind2) {
            MonikerKind2["import"] = "import";
            MonikerKind2["export"] = "export";
            MonikerKind2["local"] = "local";
        })(MonikerKind = exports.MonikerKind || (exports.MonikerKind = {}));
        var MonikerRequest;
        (function(MonikerRequest2) {
            MonikerRequest2.method = "textDocument/moniker";
            MonikerRequest2.type = new messages_1.ProtocolRequestType(MonikerRequest2.method);
        })(MonikerRequest = exports.MonikerRequest || (exports.MonikerRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.js
var require_protocol = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/protocol.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.DocumentLinkRequest = exports.CodeLensRefreshRequest = exports.CodeLensResolveRequest = exports.CodeLensRequest = 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.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.InitializeError = exports.InitializeRequest = exports.WorkDoneProgressOptions = exports.TextDocumentRegistrationOptions = exports.StaticRegistrationOptions = exports.FailureHandlingKind = exports.ResourceOperationKind = exports.UnregistrationRequest = exports.RegistrationRequest = exports.DocumentSelector = exports.DocumentFilter = void 0;
        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.SemanticTokens = exports.SemanticTokenModifiers = exports.SemanticTokenTypes = 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 = void 0;
        var Is = require_is2();
        var messages_1 = require_messages2();
        var protocol_implementation_1 = require_protocol_implementation();
        Object.defineProperty(exports, "ImplementationRequest", {
            enumerable: true,
            get: function() {
                return protocol_implementation_1.ImplementationRequest;
            }
        });
        var protocol_typeDefinition_1 = require_protocol_typeDefinition();
        Object.defineProperty(exports, "TypeDefinitionRequest", {
            enumerable: true,
            get: function() {
                return protocol_typeDefinition_1.TypeDefinitionRequest;
            }
        });
        var protocol_workspaceFolders_1 = require_protocol_workspaceFolders();
        Object.defineProperty(exports, "WorkspaceFoldersRequest", {
            enumerable: true,
            get: function() {
                return protocol_workspaceFolders_1.WorkspaceFoldersRequest;
            }
        });
        Object.defineProperty(exports, "DidChangeWorkspaceFoldersNotification", {
            enumerable: true,
            get: function() {
                return protocol_workspaceFolders_1.DidChangeWorkspaceFoldersNotification;
            }
        });
        var protocol_configuration_1 = require_protocol_configuration();
        Object.defineProperty(exports, "ConfigurationRequest", {
            enumerable: true,
            get: function() {
                return protocol_configuration_1.ConfigurationRequest;
            }
        });
        var protocol_colorProvider_1 = require_protocol_colorProvider();
        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;
            }
        });
        var protocol_foldingRange_1 = require_protocol_foldingRange();
        Object.defineProperty(exports, "FoldingRangeRequest", {
            enumerable: true,
            get: function() {
                return protocol_foldingRange_1.FoldingRangeRequest;
            }
        });
        var protocol_declaration_1 = require_protocol_declaration();
        Object.defineProperty(exports, "DeclarationRequest", {
            enumerable: true,
            get: function() {
                return protocol_declaration_1.DeclarationRequest;
            }
        });
        var protocol_selectionRange_1 = require_protocol_selectionRange();
        Object.defineProperty(exports, "SelectionRangeRequest", {
            enumerable: true,
            get: function() {
                return protocol_selectionRange_1.SelectionRangeRequest;
            }
        });
        var protocol_progress_1 = require_protocol_progress();
        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;
            }
        });
        var protocol_callHierarchy_1 = require_protocol_callHierarchy();
        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;
            }
        });
        var protocol_semanticTokens_1 = require_protocol_semanticTokens();
        Object.defineProperty(exports, "SemanticTokenTypes", {
            enumerable: true,
            get: function() {
                return protocol_semanticTokens_1.SemanticTokenTypes;
            }
        });
        Object.defineProperty(exports, "SemanticTokenModifiers", {
            enumerable: true,
            get: function() {
                return protocol_semanticTokens_1.SemanticTokenModifiers;
            }
        });
        Object.defineProperty(exports, "SemanticTokens", {
            enumerable: true,
            get: function() {
                return protocol_semanticTokens_1.SemanticTokens;
            }
        });
        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;
            }
        });
        var protocol_showDocument_1 = require_protocol_showDocument();
        Object.defineProperty(exports, "ShowDocumentRequest", {
            enumerable: true,
            get: function() {
                return protocol_showDocument_1.ShowDocumentRequest;
            }
        });
        var protocol_linkedEditingRange_1 = require_protocol_linkedEditingRange();
        Object.defineProperty(exports, "LinkedEditingRangeRequest", {
            enumerable: true,
            get: function() {
                return protocol_linkedEditingRange_1.LinkedEditingRangeRequest;
            }
        });
        var protocol_fileOperations_1 = require_protocol_fileOperations();
        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;
            }
        });
        var protocol_moniker_1 = require_protocol_moniker();
        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;
            }
        });
        var DocumentFilter;
        (function(DocumentFilter2) {
            function is(value1) {
                const candidate = value1;
                return Is.string(candidate.language) || Is.string(candidate.scheme) || Is.string(candidate.pattern);
            }
            DocumentFilter2.is = is;
        })(DocumentFilter = exports.DocumentFilter || (exports.DocumentFilter = {}));
        var DocumentSelector;
        (function(DocumentSelector2) {
            function is(value1) {
                if (!Array.isArray(value1)) {
                    return false;
                }
                for (let elem of value1){
                    if (!Is.string(elem) && !DocumentFilter.is(elem)) {
                        return false;
                    }
                }
                return true;
            }
            DocumentSelector2.is = is;
        })(DocumentSelector = exports.DocumentSelector || (exports.DocumentSelector = {}));
        var RegistrationRequest;
        (function(RegistrationRequest2) {
            RegistrationRequest2.type = new messages_1.ProtocolRequestType("client/registerCapability");
        })(RegistrationRequest = exports.RegistrationRequest || (exports.RegistrationRequest = {}));
        var UnregistrationRequest;
        (function(UnregistrationRequest2) {
            UnregistrationRequest2.type = new messages_1.ProtocolRequestType("client/unregisterCapability");
        })(UnregistrationRequest = exports.UnregistrationRequest || (exports.UnregistrationRequest = {}));
        var ResourceOperationKind;
        (function(ResourceOperationKind2) {
            ResourceOperationKind2.Create = "create";
            ResourceOperationKind2.Rename = "rename";
            ResourceOperationKind2.Delete = "delete";
        })(ResourceOperationKind = exports.ResourceOperationKind || (exports.ResourceOperationKind = {}));
        var FailureHandlingKind;
        (function(FailureHandlingKind2) {
            FailureHandlingKind2.Abort = "abort";
            FailureHandlingKind2.Transactional = "transactional";
            FailureHandlingKind2.TextOnlyTransactional = "textOnlyTransactional";
            FailureHandlingKind2.Undo = "undo";
        })(FailureHandlingKind = exports.FailureHandlingKind || (exports.FailureHandlingKind = {}));
        var StaticRegistrationOptions;
        (function(StaticRegistrationOptions2) {
            function hasId(value1) {
                const candidate = value1;
                return candidate && Is.string(candidate.id) && candidate.id.length > 0;
            }
            StaticRegistrationOptions2.hasId = hasId;
        })(StaticRegistrationOptions = exports.StaticRegistrationOptions || (exports.StaticRegistrationOptions = {}));
        var TextDocumentRegistrationOptions;
        (function(TextDocumentRegistrationOptions2) {
            function is(value1) {
                const candidate = value1;
                return candidate && (candidate.documentSelector === null || DocumentSelector.is(candidate.documentSelector));
            }
            TextDocumentRegistrationOptions2.is = is;
        })(TextDocumentRegistrationOptions = exports.TextDocumentRegistrationOptions || (exports.TextDocumentRegistrationOptions = {}));
        var WorkDoneProgressOptions;
        (function(WorkDoneProgressOptions2) {
            function is(value1) {
                const candidate = value1;
                return Is.objectLiteral(candidate) && (candidate.workDoneProgress === void 0 || Is.boolean(candidate.workDoneProgress));
            }
            WorkDoneProgressOptions2.is = is;
            function hasWorkDoneProgress(value1) {
                const candidate = value1;
                return candidate && Is.boolean(candidate.workDoneProgress);
            }
            WorkDoneProgressOptions2.hasWorkDoneProgress = hasWorkDoneProgress;
        })(WorkDoneProgressOptions = exports.WorkDoneProgressOptions || (exports.WorkDoneProgressOptions = {}));
        var InitializeRequest;
        (function(InitializeRequest2) {
            InitializeRequest2.type = new messages_1.ProtocolRequestType("initialize");
        })(InitializeRequest = exports.InitializeRequest || (exports.InitializeRequest = {}));
        var InitializeError;
        (function(InitializeError2) {
            InitializeError2.unknownProtocolVersion = 1;
        })(InitializeError = exports.InitializeError || (exports.InitializeError = {}));
        var InitializedNotification;
        (function(InitializedNotification2) {
            InitializedNotification2.type = new messages_1.ProtocolNotificationType("initialized");
        })(InitializedNotification = exports.InitializedNotification || (exports.InitializedNotification = {}));
        var ShutdownRequest;
        (function(ShutdownRequest2) {
            ShutdownRequest2.type = new messages_1.ProtocolRequestType0("shutdown");
        })(ShutdownRequest = exports.ShutdownRequest || (exports.ShutdownRequest = {}));
        var ExitNotification;
        (function(ExitNotification2) {
            ExitNotification2.type = new messages_1.ProtocolNotificationType0("exit");
        })(ExitNotification = exports.ExitNotification || (exports.ExitNotification = {}));
        var DidChangeConfigurationNotification;
        (function(DidChangeConfigurationNotification2) {
            DidChangeConfigurationNotification2.type = new messages_1.ProtocolNotificationType("workspace/didChangeConfiguration");
        })(DidChangeConfigurationNotification = exports.DidChangeConfigurationNotification || (exports.DidChangeConfigurationNotification = {}));
        var MessageType;
        (function(MessageType2) {
            MessageType2.Error = 1;
            MessageType2.Warning = 2;
            MessageType2.Info = 3;
            MessageType2.Log = 4;
        })(MessageType = exports.MessageType || (exports.MessageType = {}));
        var ShowMessageNotification;
        (function(ShowMessageNotification2) {
            ShowMessageNotification2.type = new messages_1.ProtocolNotificationType("window/showMessage");
        })(ShowMessageNotification = exports.ShowMessageNotification || (exports.ShowMessageNotification = {}));
        var ShowMessageRequest;
        (function(ShowMessageRequest2) {
            ShowMessageRequest2.type = new messages_1.ProtocolRequestType("window/showMessageRequest");
        })(ShowMessageRequest = exports.ShowMessageRequest || (exports.ShowMessageRequest = {}));
        var LogMessageNotification;
        (function(LogMessageNotification2) {
            LogMessageNotification2.type = new messages_1.ProtocolNotificationType("window/logMessage");
        })(LogMessageNotification = exports.LogMessageNotification || (exports.LogMessageNotification = {}));
        var TelemetryEventNotification;
        (function(TelemetryEventNotification2) {
            TelemetryEventNotification2.type = new messages_1.ProtocolNotificationType("telemetry/event");
        })(TelemetryEventNotification = exports.TelemetryEventNotification || (exports.TelemetryEventNotification = {}));
        var TextDocumentSyncKind;
        (function(TextDocumentSyncKind2) {
            TextDocumentSyncKind2.None = 0;
            TextDocumentSyncKind2.Full = 1;
            TextDocumentSyncKind2.Incremental = 2;
        })(TextDocumentSyncKind = exports.TextDocumentSyncKind || (exports.TextDocumentSyncKind = {}));
        var DidOpenTextDocumentNotification;
        (function(DidOpenTextDocumentNotification2) {
            DidOpenTextDocumentNotification2.method = "textDocument/didOpen";
            DidOpenTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification2.method);
        })(DidOpenTextDocumentNotification = exports.DidOpenTextDocumentNotification || (exports.DidOpenTextDocumentNotification = {}));
        var TextDocumentContentChangeEvent;
        (function(TextDocumentContentChangeEvent2) {
            function isIncremental(event) {
                let candidate = event;
                return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range !== void 0 && (candidate.rangeLength === void 0 || typeof candidate.rangeLength === "number");
            }
            TextDocumentContentChangeEvent2.isIncremental = isIncremental;
            function isFull(event) {
                let candidate = event;
                return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range === void 0 && candidate.rangeLength === void 0;
            }
            TextDocumentContentChangeEvent2.isFull = isFull;
        })(TextDocumentContentChangeEvent = exports.TextDocumentContentChangeEvent || (exports.TextDocumentContentChangeEvent = {}));
        var DidChangeTextDocumentNotification;
        (function(DidChangeTextDocumentNotification2) {
            DidChangeTextDocumentNotification2.method = "textDocument/didChange";
            DidChangeTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidChangeTextDocumentNotification2.method);
        })(DidChangeTextDocumentNotification = exports.DidChangeTextDocumentNotification || (exports.DidChangeTextDocumentNotification = {}));
        var DidCloseTextDocumentNotification;
        (function(DidCloseTextDocumentNotification2) {
            DidCloseTextDocumentNotification2.method = "textDocument/didClose";
            DidCloseTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidCloseTextDocumentNotification2.method);
        })(DidCloseTextDocumentNotification = exports.DidCloseTextDocumentNotification || (exports.DidCloseTextDocumentNotification = {}));
        var DidSaveTextDocumentNotification;
        (function(DidSaveTextDocumentNotification2) {
            DidSaveTextDocumentNotification2.method = "textDocument/didSave";
            DidSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidSaveTextDocumentNotification2.method);
        })(DidSaveTextDocumentNotification = exports.DidSaveTextDocumentNotification || (exports.DidSaveTextDocumentNotification = {}));
        var TextDocumentSaveReason;
        (function(TextDocumentSaveReason2) {
            TextDocumentSaveReason2.Manual = 1;
            TextDocumentSaveReason2.AfterDelay = 2;
            TextDocumentSaveReason2.FocusOut = 3;
        })(TextDocumentSaveReason = exports.TextDocumentSaveReason || (exports.TextDocumentSaveReason = {}));
        var WillSaveTextDocumentNotification;
        (function(WillSaveTextDocumentNotification2) {
            WillSaveTextDocumentNotification2.method = "textDocument/willSave";
            WillSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(WillSaveTextDocumentNotification2.method);
        })(WillSaveTextDocumentNotification = exports.WillSaveTextDocumentNotification || (exports.WillSaveTextDocumentNotification = {}));
        var WillSaveTextDocumentWaitUntilRequest;
        (function(WillSaveTextDocumentWaitUntilRequest2) {
            WillSaveTextDocumentWaitUntilRequest2.method = "textDocument/willSaveWaitUntil";
            WillSaveTextDocumentWaitUntilRequest2.type = new messages_1.ProtocolRequestType(WillSaveTextDocumentWaitUntilRequest2.method);
        })(WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentWaitUntilRequest || (exports.WillSaveTextDocumentWaitUntilRequest = {}));
        var DidChangeWatchedFilesNotification;
        (function(DidChangeWatchedFilesNotification2) {
            DidChangeWatchedFilesNotification2.type = new messages_1.ProtocolNotificationType("workspace/didChangeWatchedFiles");
        })(DidChangeWatchedFilesNotification = exports.DidChangeWatchedFilesNotification || (exports.DidChangeWatchedFilesNotification = {}));
        var FileChangeType;
        (function(FileChangeType2) {
            FileChangeType2.Created = 1;
            FileChangeType2.Changed = 2;
            FileChangeType2.Deleted = 3;
        })(FileChangeType = exports.FileChangeType || (exports.FileChangeType = {}));
        var WatchKind;
        (function(WatchKind2) {
            WatchKind2.Create = 1;
            WatchKind2.Change = 2;
            WatchKind2.Delete = 4;
        })(WatchKind = exports.WatchKind || (exports.WatchKind = {}));
        var PublishDiagnosticsNotification;
        (function(PublishDiagnosticsNotification2) {
            PublishDiagnosticsNotification2.type = new messages_1.ProtocolNotificationType("textDocument/publishDiagnostics");
        })(PublishDiagnosticsNotification = exports.PublishDiagnosticsNotification || (exports.PublishDiagnosticsNotification = {}));
        var CompletionTriggerKind;
        (function(CompletionTriggerKind2) {
            CompletionTriggerKind2.Invoked = 1;
            CompletionTriggerKind2.TriggerCharacter = 2;
            CompletionTriggerKind2.TriggerForIncompleteCompletions = 3;
        })(CompletionTriggerKind = exports.CompletionTriggerKind || (exports.CompletionTriggerKind = {}));
        var CompletionRequest;
        (function(CompletionRequest2) {
            CompletionRequest2.method = "textDocument/completion";
            CompletionRequest2.type = new messages_1.ProtocolRequestType(CompletionRequest2.method);
        })(CompletionRequest = exports.CompletionRequest || (exports.CompletionRequest = {}));
        var CompletionResolveRequest;
        (function(CompletionResolveRequest2) {
            CompletionResolveRequest2.method = "completionItem/resolve";
            CompletionResolveRequest2.type = new messages_1.ProtocolRequestType(CompletionResolveRequest2.method);
        })(CompletionResolveRequest = exports.CompletionResolveRequest || (exports.CompletionResolveRequest = {}));
        var HoverRequest;
        (function(HoverRequest2) {
            HoverRequest2.method = "textDocument/hover";
            HoverRequest2.type = new messages_1.ProtocolRequestType(HoverRequest2.method);
        })(HoverRequest = exports.HoverRequest || (exports.HoverRequest = {}));
        var SignatureHelpTriggerKind;
        (function(SignatureHelpTriggerKind2) {
            SignatureHelpTriggerKind2.Invoked = 1;
            SignatureHelpTriggerKind2.TriggerCharacter = 2;
            SignatureHelpTriggerKind2.ContentChange = 3;
        })(SignatureHelpTriggerKind = exports.SignatureHelpTriggerKind || (exports.SignatureHelpTriggerKind = {}));
        var SignatureHelpRequest;
        (function(SignatureHelpRequest2) {
            SignatureHelpRequest2.method = "textDocument/signatureHelp";
            SignatureHelpRequest2.type = new messages_1.ProtocolRequestType(SignatureHelpRequest2.method);
        })(SignatureHelpRequest = exports.SignatureHelpRequest || (exports.SignatureHelpRequest = {}));
        var DefinitionRequest;
        (function(DefinitionRequest2) {
            DefinitionRequest2.method = "textDocument/definition";
            DefinitionRequest2.type = new messages_1.ProtocolRequestType(DefinitionRequest2.method);
        })(DefinitionRequest = exports.DefinitionRequest || (exports.DefinitionRequest = {}));
        var ReferencesRequest;
        (function(ReferencesRequest2) {
            ReferencesRequest2.method = "textDocument/references";
            ReferencesRequest2.type = new messages_1.ProtocolRequestType(ReferencesRequest2.method);
        })(ReferencesRequest = exports.ReferencesRequest || (exports.ReferencesRequest = {}));
        var DocumentHighlightRequest;
        (function(DocumentHighlightRequest2) {
            DocumentHighlightRequest2.method = "textDocument/documentHighlight";
            DocumentHighlightRequest2.type = new messages_1.ProtocolRequestType(DocumentHighlightRequest2.method);
        })(DocumentHighlightRequest = exports.DocumentHighlightRequest || (exports.DocumentHighlightRequest = {}));
        var DocumentSymbolRequest;
        (function(DocumentSymbolRequest2) {
            DocumentSymbolRequest2.method = "textDocument/documentSymbol";
            DocumentSymbolRequest2.type = new messages_1.ProtocolRequestType(DocumentSymbolRequest2.method);
        })(DocumentSymbolRequest = exports.DocumentSymbolRequest || (exports.DocumentSymbolRequest = {}));
        var CodeActionRequest;
        (function(CodeActionRequest2) {
            CodeActionRequest2.method = "textDocument/codeAction";
            CodeActionRequest2.type = new messages_1.ProtocolRequestType(CodeActionRequest2.method);
        })(CodeActionRequest = exports.CodeActionRequest || (exports.CodeActionRequest = {}));
        var CodeActionResolveRequest;
        (function(CodeActionResolveRequest2) {
            CodeActionResolveRequest2.method = "codeAction/resolve";
            CodeActionResolveRequest2.type = new messages_1.ProtocolRequestType(CodeActionResolveRequest2.method);
        })(CodeActionResolveRequest = exports.CodeActionResolveRequest || (exports.CodeActionResolveRequest = {}));
        var WorkspaceSymbolRequest;
        (function(WorkspaceSymbolRequest2) {
            WorkspaceSymbolRequest2.method = "workspace/symbol";
            WorkspaceSymbolRequest2.type = new messages_1.ProtocolRequestType(WorkspaceSymbolRequest2.method);
        })(WorkspaceSymbolRequest = exports.WorkspaceSymbolRequest || (exports.WorkspaceSymbolRequest = {}));
        var CodeLensRequest;
        (function(CodeLensRequest2) {
            CodeLensRequest2.method = "textDocument/codeLens";
            CodeLensRequest2.type = new messages_1.ProtocolRequestType(CodeLensRequest2.method);
        })(CodeLensRequest = exports.CodeLensRequest || (exports.CodeLensRequest = {}));
        var CodeLensResolveRequest;
        (function(CodeLensResolveRequest2) {
            CodeLensResolveRequest2.method = "codeLens/resolve";
            CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType(CodeLensResolveRequest2.method);
        })(CodeLensResolveRequest = exports.CodeLensResolveRequest || (exports.CodeLensResolveRequest = {}));
        var CodeLensRefreshRequest;
        (function(CodeLensRefreshRequest2) {
            CodeLensRefreshRequest2.method = `workspace/codeLens/refresh`;
            CodeLensRefreshRequest2.type = new messages_1.ProtocolRequestType0(CodeLensRefreshRequest2.method);
        })(CodeLensRefreshRequest = exports.CodeLensRefreshRequest || (exports.CodeLensRefreshRequest = {}));
        var DocumentLinkRequest;
        (function(DocumentLinkRequest2) {
            DocumentLinkRequest2.method = "textDocument/documentLink";
            DocumentLinkRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkRequest2.method);
        })(DocumentLinkRequest = exports.DocumentLinkRequest || (exports.DocumentLinkRequest = {}));
        var DocumentLinkResolveRequest;
        (function(DocumentLinkResolveRequest2) {
            DocumentLinkResolveRequest2.method = "documentLink/resolve";
            DocumentLinkResolveRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkResolveRequest2.method);
        })(DocumentLinkResolveRequest = exports.DocumentLinkResolveRequest || (exports.DocumentLinkResolveRequest = {}));
        var DocumentFormattingRequest;
        (function(DocumentFormattingRequest2) {
            DocumentFormattingRequest2.method = "textDocument/formatting";
            DocumentFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentFormattingRequest2.method);
        })(DocumentFormattingRequest = exports.DocumentFormattingRequest || (exports.DocumentFormattingRequest = {}));
        var DocumentRangeFormattingRequest;
        (function(DocumentRangeFormattingRequest2) {
            DocumentRangeFormattingRequest2.method = "textDocument/rangeFormatting";
            DocumentRangeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentRangeFormattingRequest2.method);
        })(DocumentRangeFormattingRequest = exports.DocumentRangeFormattingRequest || (exports.DocumentRangeFormattingRequest = {}));
        var DocumentOnTypeFormattingRequest;
        (function(DocumentOnTypeFormattingRequest2) {
            DocumentOnTypeFormattingRequest2.method = "textDocument/onTypeFormatting";
            DocumentOnTypeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest2.method);
        })(DocumentOnTypeFormattingRequest = exports.DocumentOnTypeFormattingRequest || (exports.DocumentOnTypeFormattingRequest = {}));
        var PrepareSupportDefaultBehavior;
        (function(PrepareSupportDefaultBehavior2) {
            PrepareSupportDefaultBehavior2.Identifier = 1;
        })(PrepareSupportDefaultBehavior = exports.PrepareSupportDefaultBehavior || (exports.PrepareSupportDefaultBehavior = {}));
        var RenameRequest;
        (function(RenameRequest2) {
            RenameRequest2.method = "textDocument/rename";
            RenameRequest2.type = new messages_1.ProtocolRequestType(RenameRequest2.method);
        })(RenameRequest = exports.RenameRequest || (exports.RenameRequest = {}));
        var PrepareRenameRequest;
        (function(PrepareRenameRequest2) {
            PrepareRenameRequest2.method = "textDocument/prepareRename";
            PrepareRenameRequest2.type = new messages_1.ProtocolRequestType(PrepareRenameRequest2.method);
        })(PrepareRenameRequest = exports.PrepareRenameRequest || (exports.PrepareRenameRequest = {}));
        var ExecuteCommandRequest;
        (function(ExecuteCommandRequest2) {
            ExecuteCommandRequest2.type = new messages_1.ProtocolRequestType("workspace/executeCommand");
        })(ExecuteCommandRequest = exports.ExecuteCommandRequest || (exports.ExecuteCommandRequest = {}));
        var ApplyWorkspaceEditRequest;
        (function(ApplyWorkspaceEditRequest2) {
            ApplyWorkspaceEditRequest2.type = new messages_1.ProtocolRequestType("workspace/applyEdit");
        })(ApplyWorkspaceEditRequest = exports.ApplyWorkspaceEditRequest || (exports.ApplyWorkspaceEditRequest = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/connection.js
var require_connection2 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/connection.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.createProtocolConnection = void 0;
        var vscode_jsonrpc_1 = require_main2();
        function createProtocolConnection(input, output, logger, options) {
            if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) {
                options = {
                    connectionStrategy: options
                };
            }
            return vscode_jsonrpc_1.createMessageConnection(input, output, logger, options);
        }
        exports.createProtocolConnection = createProtocolConnection;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/api.js
var require_api2 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/common/api.js" (exports) {
        "use strict";
        var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
            if (k2 === void 0) k2 = k;
            Object.defineProperty(o, k2, {
                enumerable: true,
                get: function() {
                    return m[k];
                }
            });
        } : function(o, m, k, k2) {
            if (k2 === void 0) k2 = k;
            o[k2] = m[k];
        });
        var __exportStar = exports && exports.__exportStar || function(m, exports2) {
            for(var p in m)if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
        };
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.LSPErrorCodes = exports.createProtocolConnection = void 0;
        __exportStar(require_main2(), exports);
        __exportStar(require_main(), exports);
        __exportStar(require_messages2(), exports);
        __exportStar(require_protocol(), exports);
        var connection_1 = require_connection2();
        Object.defineProperty(exports, "createProtocolConnection", {
            enumerable: true,
            get: function() {
                return connection_1.createProtocolConnection;
            }
        });
        var LSPErrorCodes;
        (function(LSPErrorCodes2) {
            LSPErrorCodes2.lspReservedErrorRangeStart = -32899;
            LSPErrorCodes2.ContentModified = -32801;
            LSPErrorCodes2.RequestCancelled = -32800;
            LSPErrorCodes2.lspReservedErrorRangeEnd = -32800;
        })(LSPErrorCodes = exports.LSPErrorCodes || (exports.LSPErrorCodes = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/browser/main.js
var require_main3 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/lib/browser/main.js" (exports) {
        "use strict";
        var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
            if (k2 === void 0) k2 = k;
            Object.defineProperty(o, k2, {
                enumerable: true,
                get: function() {
                    return m[k];
                }
            });
        } : function(o, m, k, k2) {
            if (k2 === void 0) k2 = k;
            o[k2] = m[k];
        });
        var __exportStar = exports && exports.__exportStar || function(m, exports2) {
            for(var p in m)if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
        };
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.createProtocolConnection = void 0;
        var browser_1 = require_browser();
        __exportStar(require_browser(), exports);
        __exportStar(require_api2(), exports);
        function createProtocolConnection(reader, writer, logger, options) {
            return browser_1.createMessageConnection(reader, writer, logger, options);
        }
        exports.createProtocolConnection = createProtocolConnection;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/semanticTokens.js
var require_semanticTokens = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/semanticTokens.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.SemanticTokensBuilder = exports.SemanticTokensFeature = void 0;
        var vscode_languageserver_protocol_1 = require_main3();
        var SemanticTokensFeature = (Base)=>{
            return class extends Base {
                get semanticTokens() {
                    return {
                        on: (handler)=>{
                            const type = vscode_languageserver_protocol_1.SemanticTokensRequest.type;
                            this.connection.onRequest(type, (params, cancel)=>{
                                return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                            });
                        },
                        onDelta: (handler)=>{
                            const type = vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type;
                            this.connection.onRequest(type, (params, cancel)=>{
                                return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                            });
                        },
                        onRange: (handler)=>{
                            const type = vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type;
                            this.connection.onRequest(type, (params, cancel)=>{
                                return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                            });
                        }
                    };
                }
            };
        };
        exports.SemanticTokensFeature = SemanticTokensFeature;
        var SemanticTokensBuilder = class {
            initialize() {
                this._id = Date.now();
                this._prevLine = 0;
                this._prevChar = 0;
                this._data = [];
                this._dataLen = 0;
            }
            push(line, char, length, tokenType2, tokenModifiers) {
                let pushLine = line;
                let pushChar = char;
                if (this._dataLen > 0) {
                    pushLine -= this._prevLine;
                    if (pushLine === 0) {
                        pushChar -= this._prevChar;
                    }
                }
                this._data[this._dataLen++] = pushLine;
                this._data[this._dataLen++] = pushChar;
                this._data[this._dataLen++] = length;
                this._data[this._dataLen++] = tokenType2;
                this._data[this._dataLen++] = tokenModifiers;
                this._prevLine = line;
                this._prevChar = char;
            }
            get id() {
                return this._id.toString();
            }
            previousResult(id) {
                if (this.id === id) {
                    this._prevData = this._data;
                }
                this.initialize();
            }
            build() {
                this._prevData = void 0;
                return {
                    resultId: this.id,
                    data: this._data
                };
            }
            canBuildEdits() {
                return this._prevData !== void 0;
            }
            buildEdits() {
                if (this._prevData !== void 0) {
                    const prevDataLength = this._prevData.length;
                    const dataLength = this._data.length;
                    let startIndex = 0;
                    while(startIndex < dataLength && startIndex < prevDataLength && this._prevData[startIndex] === this._data[startIndex]){
                        startIndex++;
                    }
                    if (startIndex < dataLength && startIndex < prevDataLength) {
                        let endIndex = 0;
                        while(endIndex < dataLength && endIndex < prevDataLength && this._prevData[prevDataLength - 1 - endIndex] === this._data[dataLength - 1 - endIndex]){
                            endIndex++;
                        }
                        const newData = this._data.slice(startIndex, dataLength - endIndex);
                        const result = {
                            resultId: this.id,
                            edits: [
                                {
                                    start: startIndex,
                                    deleteCount: prevDataLength - endIndex - startIndex,
                                    data: newData
                                }
                            ]
                        };
                        return result;
                    } else if (startIndex < dataLength) {
                        return {
                            resultId: this.id,
                            edits: [
                                {
                                    start: startIndex,
                                    deleteCount: 0,
                                    data: this._data.slice(startIndex)
                                }
                            ]
                        };
                    } else if (startIndex < prevDataLength) {
                        return {
                            resultId: this.id,
                            edits: [
                                {
                                    start: startIndex,
                                    deleteCount: prevDataLength - startIndex
                                }
                            ]
                        };
                    } else {
                        return {
                            resultId: this.id,
                            edits: []
                        };
                    }
                } else {
                    return this.build();
                }
            }
            constructor(){
                this._prevData = void 0;
                this.initialize();
            }
        };
        exports.SemanticTokensBuilder = SemanticTokensBuilder;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/utils/is.js
var require_is3 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/utils/is.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.thenable = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
        function boolean(value1) {
            return value1 === true || value1 === false;
        }
        exports.boolean = boolean;
        function string2(value1) {
            return typeof value1 === "string" || value1 instanceof String;
        }
        exports.string = string2;
        function number(value1) {
            return typeof value1 === "number" || value1 instanceof Number;
        }
        exports.number = number;
        function error(value1) {
            return value1 instanceof Error;
        }
        exports.error = error;
        function func(value1) {
            return typeof value1 === "function";
        }
        exports.func = func;
        function array(value1) {
            return Array.isArray(value1);
        }
        exports.array = array;
        function stringArray(value1) {
            return array(value1) && value1.every((elem)=>string2(elem));
        }
        exports.stringArray = stringArray;
        function typedArray(value1, check) {
            return Array.isArray(value1) && value1.every(check);
        }
        exports.typedArray = typedArray;
        function thenable(value1) {
            return value1 && func(value1.then);
        }
        exports.thenable = thenable;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/utils/uuid.js
var require_uuid = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/utils/uuid.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.generateUuid = exports.parse = exports.isUUID = exports.v4 = exports.empty = void 0;
        var ValueUUID = class {
            asHex() {
                return this._value;
            }
            equals(other) {
                return this.asHex() === other.asHex();
            }
            constructor(_value){
                this._value = _value;
            }
        };
        var V4UUID = class _V4UUID extends ValueUUID {
            static _oneOf(array) {
                return array[Math.floor(array.length * Math.random())];
            }
            static _randomHex() {
                return _V4UUID._oneOf(_V4UUID._chars);
            }
            constructor(){
                super([
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    "-",
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    "-",
                    "4",
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    "-",
                    _V4UUID._oneOf(_V4UUID._timeHighBits),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    "-",
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex(),
                    _V4UUID._randomHex()
                ].join(""));
            }
        };
        V4UUID._chars = [
            "0",
            "1",
            "2",
            "3",
            "4",
            "5",
            "6",
            "6",
            "7",
            "8",
            "9",
            "a",
            "b",
            "c",
            "d",
            "e",
            "f"
        ];
        V4UUID._timeHighBits = [
            "8",
            "9",
            "a",
            "b"
        ];
        exports.empty = new ValueUUID("00000000-0000-0000-0000-000000000000");
        function v4() {
            return new V4UUID();
        }
        exports.v4 = v4;
        var _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
        function isUUID(value1) {
            return _UUIDPattern.test(value1);
        }
        exports.isUUID = isUUID;
        function parse7(value1) {
            if (!isUUID(value1)) {
                throw new Error("invalid uuid");
            }
            return new ValueUUID(value1);
        }
        exports.parse = parse7;
        function generateUuid() {
            return v4().asHex();
        }
        exports.generateUuid = generateUuid;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/progress.js
var require_progress = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/progress.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.attachPartialResult = exports.ProgressFeature = exports.attachWorkDone = void 0;
        var vscode_languageserver_protocol_1 = require_main3();
        var uuid_1 = require_uuid();
        var WorkDoneProgressReporterImpl = class _WorkDoneProgressReporterImpl {
            begin(title, percentage, message, cancellable) {
                let param = {
                    kind: "begin",
                    title,
                    percentage,
                    message,
                    cancellable
                };
                this._connection.sendProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, param);
            }
            report(arg0, arg1) {
                let param = {
                    kind: "report"
                };
                if (typeof arg0 === "number") {
                    param.percentage = arg0;
                    if (arg1 !== void 0) {
                        param.message = arg1;
                    }
                } else {
                    param.message = arg0;
                }
                this._connection.sendProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, param);
            }
            done() {
                _WorkDoneProgressReporterImpl.Instances.delete(this._token);
                this._connection.sendProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, {
                    kind: "end"
                });
            }
            constructor(_connection, _token){
                this._connection = _connection;
                this._token = _token;
                _WorkDoneProgressReporterImpl.Instances.set(this._token, this);
            }
        };
        WorkDoneProgressReporterImpl.Instances = /* @__PURE__ */ new Map();
        var WorkDoneProgressServerReporterImpl = class extends WorkDoneProgressReporterImpl {
            get token() {
                return this._source.token;
            }
            done() {
                this._source.dispose();
                super.done();
            }
            cancel() {
                this._source.cancel();
            }
            constructor(connection, token){
                super(connection, token);
                this._source = new vscode_languageserver_protocol_1.CancellationTokenSource();
            }
        };
        var NullProgressReporter = class {
            begin() {}
            report() {}
            done() {}
            constructor(){}
        };
        var NullProgressServerReporter = class extends NullProgressReporter {
            get token() {
                return this._source.token;
            }
            done() {
                this._source.dispose();
            }
            cancel() {
                this._source.cancel();
            }
            constructor(){
                super();
                this._source = new vscode_languageserver_protocol_1.CancellationTokenSource();
            }
        };
        function attachWorkDone(connection, params) {
            if (params === void 0 || params.workDoneToken === void 0) {
                return new NullProgressReporter();
            }
            const token = params.workDoneToken;
            delete params.workDoneToken;
            return new WorkDoneProgressReporterImpl(connection, token);
        }
        exports.attachWorkDone = attachWorkDone;
        var ProgressFeature = (Base)=>{
            return class extends Base {
                initialize(capabilities) {
                    var _a;
                    if (((_a = capabilities === null || capabilities === void 0 ? void 0 : capabilities.window) === null || _a === void 0 ? void 0 : _a.workDoneProgress) === true) {
                        this._progressSupported = true;
                        this.connection.onNotification(vscode_languageserver_protocol_1.WorkDoneProgressCancelNotification.type, (params)=>{
                            let progress = WorkDoneProgressReporterImpl.Instances.get(params.token);
                            if (progress instanceof WorkDoneProgressServerReporterImpl || progress instanceof NullProgressServerReporter) {
                                progress.cancel();
                            }
                        });
                    }
                }
                attachWorkDoneProgress(token) {
                    if (token === void 0) {
                        return new NullProgressReporter();
                    } else {
                        return new WorkDoneProgressReporterImpl(this.connection, token);
                    }
                }
                createWorkDoneProgress() {
                    if (this._progressSupported) {
                        const token = uuid_1.generateUuid();
                        return this.connection.sendRequest(vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest.type, {
                            token
                        }).then(()=>{
                            const result = new WorkDoneProgressServerReporterImpl(this.connection, token);
                            return result;
                        });
                    } else {
                        return Promise.resolve(new NullProgressServerReporter());
                    }
                }
                constructor(){
                    super();
                    this._progressSupported = false;
                }
            };
        };
        exports.ProgressFeature = ProgressFeature;
        var ResultProgress;
        (function(ResultProgress2) {
            ResultProgress2.type = new vscode_languageserver_protocol_1.ProgressType();
        })(ResultProgress || (ResultProgress = {}));
        var ResultProgressReporterImpl = class {
            report(data) {
                this._connection.sendProgress(ResultProgress.type, this._token, data);
            }
            constructor(_connection, _token){
                this._connection = _connection;
                this._token = _token;
            }
        };
        function attachPartialResult(connection, params) {
            if (params === void 0 || params.partialResultToken === void 0) {
                return void 0;
            }
            const token = params.partialResultToken;
            delete params.partialResultToken;
            return new ResultProgressReporterImpl(connection, token);
        }
        exports.attachPartialResult = attachPartialResult;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/configuration.js
var require_configuration = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/configuration.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.ConfigurationFeature = void 0;
        var vscode_languageserver_protocol_1 = require_main3();
        var Is = require_is3();
        var ConfigurationFeature = (Base)=>{
            return class extends Base {
                getConfiguration(arg) {
                    if (!arg) {
                        return this._getConfiguration({});
                    } else if (Is.string(arg)) {
                        return this._getConfiguration({
                            section: arg
                        });
                    } else {
                        return this._getConfiguration(arg);
                    }
                }
                _getConfiguration(arg) {
                    let params = {
                        items: Array.isArray(arg) ? arg : [
                            arg
                        ]
                    };
                    return this.connection.sendRequest(vscode_languageserver_protocol_1.ConfigurationRequest.type, params).then((result)=>{
                        return Array.isArray(arg) ? result : result[0];
                    });
                }
            };
        };
        exports.ConfigurationFeature = ConfigurationFeature;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/workspaceFolders.js
var require_workspaceFolders = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/workspaceFolders.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.WorkspaceFoldersFeature = void 0;
        var vscode_languageserver_protocol_1 = require_main3();
        var WorkspaceFoldersFeature = (Base)=>{
            return class extends Base {
                initialize(capabilities) {
                    let workspaceCapabilities = capabilities.workspace;
                    if (workspaceCapabilities && workspaceCapabilities.workspaceFolders) {
                        this._onDidChangeWorkspaceFolders = new vscode_languageserver_protocol_1.Emitter();
                        this.connection.onNotification(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type, (params)=>{
                            this._onDidChangeWorkspaceFolders.fire(params.event);
                        });
                    }
                }
                getWorkspaceFolders() {
                    return this.connection.sendRequest(vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type);
                }
                get onDidChangeWorkspaceFolders() {
                    if (!this._onDidChangeWorkspaceFolders) {
                        throw new Error("Client doesn't support sending workspace folder change events.");
                    }
                    if (!this._unregistration) {
                        this._unregistration = this.connection.client.register(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type);
                    }
                    return this._onDidChangeWorkspaceFolders.event;
                }
            };
        };
        exports.WorkspaceFoldersFeature = WorkspaceFoldersFeature;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/callHierarchy.js
var require_callHierarchy = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/callHierarchy.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.CallHierarchyFeature = void 0;
        var vscode_languageserver_protocol_1 = require_main3();
        var CallHierarchyFeature = (Base)=>{
            return class extends Base {
                get callHierarchy() {
                    return {
                        onPrepare: (handler)=>{
                            this.connection.onRequest(vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type, (params, cancel)=>{
                                return handler(params, cancel, this.attachWorkDoneProgress(params), void 0);
                            });
                        },
                        onIncomingCalls: (handler)=>{
                            const type = vscode_languageserver_protocol_1.CallHierarchyIncomingCallsRequest.type;
                            this.connection.onRequest(type, (params, cancel)=>{
                                return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                            });
                        },
                        onOutgoingCalls: (handler)=>{
                            const type = vscode_languageserver_protocol_1.CallHierarchyOutgoingCallsRequest.type;
                            this.connection.onRequest(type, (params, cancel)=>{
                                return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                            });
                        }
                    };
                }
            };
        };
        exports.CallHierarchyFeature = CallHierarchyFeature;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/showDocument.js
var require_showDocument = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/showDocument.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.ShowDocumentFeature = void 0;
        var vscode_languageserver_protocol_1 = require_main3();
        var ShowDocumentFeature = (Base)=>{
            return class extends Base {
                showDocument(params) {
                    return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowDocumentRequest.type, params);
                }
            };
        };
        exports.ShowDocumentFeature = ShowDocumentFeature;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/fileOperations.js
var require_fileOperations = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/fileOperations.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.FileOperationsFeature = void 0;
        var vscode_languageserver_protocol_1 = require_main3();
        var FileOperationsFeature = (Base)=>{
            return class extends Base {
                onDidCreateFiles(handler) {
                    this.connection.onNotification(vscode_languageserver_protocol_1.DidCreateFilesNotification.type, (params)=>{
                        handler(params);
                    });
                }
                onDidRenameFiles(handler) {
                    this.connection.onNotification(vscode_languageserver_protocol_1.DidRenameFilesNotification.type, (params)=>{
                        handler(params);
                    });
                }
                onDidDeleteFiles(handler) {
                    this.connection.onNotification(vscode_languageserver_protocol_1.DidDeleteFilesNotification.type, (params)=>{
                        handler(params);
                    });
                }
                onWillCreateFiles(handler) {
                    return this.connection.onRequest(vscode_languageserver_protocol_1.WillCreateFilesRequest.type, (params, cancel)=>{
                        return handler(params, cancel);
                    });
                }
                onWillRenameFiles(handler) {
                    return this.connection.onRequest(vscode_languageserver_protocol_1.WillRenameFilesRequest.type, (params, cancel)=>{
                        return handler(params, cancel);
                    });
                }
                onWillDeleteFiles(handler) {
                    return this.connection.onRequest(vscode_languageserver_protocol_1.WillDeleteFilesRequest.type, (params, cancel)=>{
                        return handler(params, cancel);
                    });
                }
            };
        };
        exports.FileOperationsFeature = FileOperationsFeature;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/linkedEditingRange.js
var require_linkedEditingRange = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/linkedEditingRange.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.LinkedEditingRangeFeature = void 0;
        var vscode_languageserver_protocol_1 = require_main3();
        var LinkedEditingRangeFeature = (Base)=>{
            return class extends Base {
                onLinkedEditingRange(handler) {
                    this.connection.onRequest(vscode_languageserver_protocol_1.LinkedEditingRangeRequest.type, (params, cancel)=>{
                        return handler(params, cancel, this.attachWorkDoneProgress(params), void 0);
                    });
                }
            };
        };
        exports.LinkedEditingRangeFeature = LinkedEditingRangeFeature;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/moniker.js
var require_moniker = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/moniker.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.MonikerFeature = void 0;
        var vscode_languageserver_protocol_1 = require_main3();
        var MonikerFeature = (Base)=>{
            return class extends Base {
                get moniker() {
                    return {
                        on: (handler)=>{
                            const type = vscode_languageserver_protocol_1.MonikerRequest.type;
                            this.connection.onRequest(type, (params, cancel)=>{
                                return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                            });
                        }
                    };
                }
            };
        };
        exports.MonikerFeature = MonikerFeature;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/server.js
var require_server = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/server.js" (exports) {
        "use strict";
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.createConnection = exports.combineFeatures = exports.combineLanguagesFeatures = exports.combineWorkspaceFeatures = exports.combineWindowFeatures = exports.combineClientFeatures = exports.combineTracerFeatures = exports.combineTelemetryFeatures = exports.combineConsoleFeatures = exports._LanguagesImpl = exports.BulkUnregistration = exports.BulkRegistration = exports.ErrorMessageTracker = exports.TextDocuments = void 0;
        var vscode_languageserver_protocol_1 = require_main3();
        var Is = require_is3();
        var UUID = require_uuid();
        var progress_1 = require_progress();
        var configuration_1 = require_configuration();
        var workspaceFolders_1 = require_workspaceFolders();
        var callHierarchy_1 = require_callHierarchy();
        var semanticTokens_1 = require_semanticTokens();
        var showDocument_1 = require_showDocument();
        var fileOperations_1 = require_fileOperations();
        var linkedEditingRange_1 = require_linkedEditingRange();
        var moniker_1 = require_moniker();
        function null2Undefined(value1) {
            if (value1 === null) {
                return void 0;
            }
            return value1;
        }
        var TextDocuments2 = class {
            /**
       * An event that fires when a text document managed by this manager
       * has been opened or the content changes.
       */ get onDidChangeContent() {
                return this._onDidChangeContent.event;
            }
            /**
       * An event that fires when a text document managed by this manager
       * has been opened.
       */ get onDidOpen() {
                return this._onDidOpen.event;
            }
            /**
       * An event that fires when a text document managed by this manager
       * will be saved.
       */ get onWillSave() {
                return this._onWillSave.event;
            }
            /**
       * Sets a handler that will be called if a participant wants to provide
       * edits during a text document save.
       */ onWillSaveWaitUntil(handler) {
                this._willSaveWaitUntil = handler;
            }
            /**
       * An event that fires when a text document managed by this manager
       * has been saved.
       */ get onDidSave() {
                return this._onDidSave.event;
            }
            /**
       * An event that fires when a text document managed by this manager
       * has been closed.
       */ get onDidClose() {
                return this._onDidClose.event;
            }
            /**
       * Returns the document for the given URI. Returns undefined if
       * the document is not managed by this instance.
       *
       * @param uri The text document's URI to retrieve.
       * @return the text document or `undefined`.
       */ get(uri) {
                return this._documents[uri];
            }
            /**
       * Returns all text documents managed by this instance.
       *
       * @return all text documents.
       */ all() {
                return Object.keys(this._documents).map((key)=>this._documents[key]);
            }
            /**
       * Returns the URIs of all text documents managed by this instance.
       *
       * @return the URI's of all text documents.
       */ keys() {
                return Object.keys(this._documents);
            }
            /**
       * Listens for `low level` notification on the given connection to
       * update the text documents managed by this instance.
       *
       * Please note that the connection only provides handlers not an event model. Therefore
       * listening on a connection will overwrite the following handlers on a connection:
       * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
       * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
       *
       * Use the corresponding events on the TextDocuments instance instead.
       *
       * @param connection The connection to listen on.
       */ listen(connection) {
                connection.__textDocumentSync = vscode_languageserver_protocol_1.TextDocumentSyncKind.Full;
                connection.onDidOpenTextDocument((event)=>{
                    let td = event.textDocument;
                    let document2 = this._configuration.create(td.uri, td.languageId, td.version, td.text);
                    this._documents[td.uri] = document2;
                    let toFire = Object.freeze({
                        document: document2
                    });
                    this._onDidOpen.fire(toFire);
                    this._onDidChangeContent.fire(toFire);
                });
                connection.onDidChangeTextDocument((event)=>{
                    let td = event.textDocument;
                    let changes = event.contentChanges;
                    if (changes.length === 0) {
                        return;
                    }
                    let document2 = this._documents[td.uri];
                    const { version } = td;
                    if (version === null || version === void 0) {
                        throw new Error(`Received document change event for ${td.uri} without valid version identifier`);
                    }
                    document2 = this._configuration.update(document2, changes, version);
                    this._documents[td.uri] = document2;
                    this._onDidChangeContent.fire(Object.freeze({
                        document: document2
                    }));
                });
                connection.onDidCloseTextDocument((event)=>{
                    let document2 = this._documents[event.textDocument.uri];
                    if (document2) {
                        delete this._documents[event.textDocument.uri];
                        this._onDidClose.fire(Object.freeze({
                            document: document2
                        }));
                    }
                });
                connection.onWillSaveTextDocument((event)=>{
                    let document2 = this._documents[event.textDocument.uri];
                    if (document2) {
                        this._onWillSave.fire(Object.freeze({
                            document: document2,
                            reason: event.reason
                        }));
                    }
                });
                connection.onWillSaveTextDocumentWaitUntil((event, token)=>{
                    let document2 = this._documents[event.textDocument.uri];
                    if (document2 && this._willSaveWaitUntil) {
                        return this._willSaveWaitUntil(Object.freeze({
                            document: document2,
                            reason: event.reason
                        }), token);
                    } else {
                        return [];
                    }
                });
                connection.onDidSaveTextDocument((event)=>{
                    let document2 = this._documents[event.textDocument.uri];
                    if (document2) {
                        this._onDidSave.fire(Object.freeze({
                            document: document2
                        }));
                    }
                });
            }
            /**
       * Create a new text document manager.
       */ constructor(configuration){
                this._documents = /* @__PURE__ */ Object.create(null);
                this._configuration = configuration;
                this._onDidChangeContent = new vscode_languageserver_protocol_1.Emitter();
                this._onDidOpen = new vscode_languageserver_protocol_1.Emitter();
                this._onDidClose = new vscode_languageserver_protocol_1.Emitter();
                this._onDidSave = new vscode_languageserver_protocol_1.Emitter();
                this._onWillSave = new vscode_languageserver_protocol_1.Emitter();
            }
        };
        exports.TextDocuments = TextDocuments2;
        var ErrorMessageTracker = class {
            /**
       * Add a message to the tracker.
       *
       * @param message The message to add.
       */ add(message) {
                let count = this._messages[message];
                if (!count) {
                    count = 0;
                }
                count++;
                this._messages[message] = count;
            }
            /**
       * Send all tracked messages to the connection's window.
       *
       * @param connection The connection established between client and server.
       */ sendErrors(connection) {
                Object.keys(this._messages).forEach((message)=>{
                    connection.window.showErrorMessage(message);
                });
            }
            constructor(){
                this._messages = /* @__PURE__ */ Object.create(null);
            }
        };
        exports.ErrorMessageTracker = ErrorMessageTracker;
        var RemoteConsoleImpl = class {
            rawAttach(connection) {
                this._rawConnection = connection;
            }
            attach(connection) {
                this._connection = connection;
            }
            get connection() {
                if (!this._connection) {
                    throw new Error("Remote is not attached to a connection yet.");
                }
                return this._connection;
            }
            fillServerCapabilities(_capabilities) {}
            initialize(_capabilities) {}
            error(message) {
                this.send(vscode_languageserver_protocol_1.MessageType.Error, message);
            }
            warn(message) {
                this.send(vscode_languageserver_protocol_1.MessageType.Warning, message);
            }
            info(message) {
                this.send(vscode_languageserver_protocol_1.MessageType.Info, message);
            }
            log(message) {
                this.send(vscode_languageserver_protocol_1.MessageType.Log, message);
            }
            send(type, message) {
                if (this._rawConnection) {
                    this._rawConnection.sendNotification(vscode_languageserver_protocol_1.LogMessageNotification.type, {
                        type,
                        message
                    });
                }
            }
            constructor(){}
        };
        var _RemoteWindowImpl = class {
            attach(connection) {
                this._connection = connection;
            }
            get connection() {
                if (!this._connection) {
                    throw new Error("Remote is not attached to a connection yet.");
                }
                return this._connection;
            }
            initialize(_capabilities) {}
            fillServerCapabilities(_capabilities) {}
            showErrorMessage(message, ...actions) {
                let params = {
                    type: vscode_languageserver_protocol_1.MessageType.Error,
                    message,
                    actions
                };
                return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
            }
            showWarningMessage(message, ...actions) {
                let params = {
                    type: vscode_languageserver_protocol_1.MessageType.Warning,
                    message,
                    actions
                };
                return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
            }
            showInformationMessage(message, ...actions) {
                let params = {
                    type: vscode_languageserver_protocol_1.MessageType.Info,
                    message,
                    actions
                };
                return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
            }
            constructor(){}
        };
        var RemoteWindowImpl = showDocument_1.ShowDocumentFeature(progress_1.ProgressFeature(_RemoteWindowImpl));
        var BulkRegistration;
        (function(BulkRegistration2) {
            function create() {
                return new BulkRegistrationImpl();
            }
            BulkRegistration2.create = create;
        })(BulkRegistration = exports.BulkRegistration || (exports.BulkRegistration = {}));
        var BulkRegistrationImpl = class {
            add(type, registerOptions) {
                const method = Is.string(type) ? type : type.method;
                if (this._registered.has(method)) {
                    throw new Error(`${method} is already added to this registration`);
                }
                const id = UUID.generateUuid();
                this._registrations.push({
                    id,
                    method,
                    registerOptions: registerOptions || {}
                });
                this._registered.add(method);
            }
            asRegistrationParams() {
                return {
                    registrations: this._registrations
                };
            }
            constructor(){
                this._registrations = [];
                this._registered = /* @__PURE__ */ new Set();
            }
        };
        var BulkUnregistration;
        (function(BulkUnregistration2) {
            function create() {
                return new BulkUnregistrationImpl(void 0, []);
            }
            BulkUnregistration2.create = create;
        })(BulkUnregistration = exports.BulkUnregistration || (exports.BulkUnregistration = {}));
        var BulkUnregistrationImpl = class {
            get isAttached() {
                return !!this._connection;
            }
            attach(connection) {
                this._connection = connection;
            }
            add(unregistration) {
                this._unregistrations.set(unregistration.method, unregistration);
            }
            dispose() {
                let unregistrations = [];
                for (let unregistration of this._unregistrations.values()){
                    unregistrations.push(unregistration);
                }
                let params = {
                    unregisterations: unregistrations
                };
                this._connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).then(void 0, (_error)=>{
                    this._connection.console.info(`Bulk unregistration failed.`);
                });
            }
            disposeSingle(arg) {
                const method = Is.string(arg) ? arg : arg.method;
                const unregistration = this._unregistrations.get(method);
                if (!unregistration) {
                    return false;
                }
                let params = {
                    unregisterations: [
                        unregistration
                    ]
                };
                this._connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).then(()=>{
                    this._unregistrations.delete(method);
                }, (_error)=>{
                    this._connection.console.info(`Un-registering request handler for ${unregistration.id} failed.`);
                });
                return true;
            }
            constructor(_connection, unregistrations){
                this._connection = _connection;
                this._unregistrations = /* @__PURE__ */ new Map();
                unregistrations.forEach((unregistration)=>{
                    this._unregistrations.set(unregistration.method, unregistration);
                });
            }
        };
        var RemoteClientImpl = class {
            attach(connection) {
                this._connection = connection;
            }
            get connection() {
                if (!this._connection) {
                    throw new Error("Remote is not attached to a connection yet.");
                }
                return this._connection;
            }
            initialize(_capabilities) {}
            fillServerCapabilities(_capabilities) {}
            register(typeOrRegistrations, registerOptionsOrType, registerOptions) {
                if (typeOrRegistrations instanceof BulkRegistrationImpl) {
                    return this.registerMany(typeOrRegistrations);
                } else if (typeOrRegistrations instanceof BulkUnregistrationImpl) {
                    return this.registerSingle1(typeOrRegistrations, registerOptionsOrType, registerOptions);
                } else {
                    return this.registerSingle2(typeOrRegistrations, registerOptionsOrType);
                }
            }
            registerSingle1(unregistration, type, registerOptions) {
                const method = Is.string(type) ? type : type.method;
                const id = UUID.generateUuid();
                let params = {
                    registrations: [
                        {
                            id,
                            method,
                            registerOptions: registerOptions || {}
                        }
                    ]
                };
                if (!unregistration.isAttached) {
                    unregistration.attach(this.connection);
                }
                return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then((_result)=>{
                    unregistration.add({
                        id,
                        method
                    });
                    return unregistration;
                }, (_error)=>{
                    this.connection.console.info(`Registering request handler for ${method} failed.`);
                    return Promise.reject(_error);
                });
            }
            registerSingle2(type, registerOptions) {
                const method = Is.string(type) ? type : type.method;
                const id = UUID.generateUuid();
                let params = {
                    registrations: [
                        {
                            id,
                            method,
                            registerOptions: registerOptions || {}
                        }
                    ]
                };
                return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then((_result)=>{
                    return vscode_languageserver_protocol_1.Disposable.create(()=>{
                        this.unregisterSingle(id, method);
                    });
                }, (_error)=>{
                    this.connection.console.info(`Registering request handler for ${method} failed.`);
                    return Promise.reject(_error);
                });
            }
            unregisterSingle(id, method) {
                let params = {
                    unregisterations: [
                        {
                            id,
                            method
                        }
                    ]
                };
                return this.connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).then(void 0, (_error)=>{
                    this.connection.console.info(`Un-registering request handler for ${id} failed.`);
                });
            }
            registerMany(registrations) {
                let params = registrations.asRegistrationParams();
                return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then(()=>{
                    return new BulkUnregistrationImpl(this._connection, params.registrations.map((registration)=>{
                        return {
                            id: registration.id,
                            method: registration.method
                        };
                    }));
                }, (_error)=>{
                    this.connection.console.info(`Bulk registration failed.`);
                    return Promise.reject(_error);
                });
            }
        };
        var _RemoteWorkspaceImpl = class {
            attach(connection) {
                this._connection = connection;
            }
            get connection() {
                if (!this._connection) {
                    throw new Error("Remote is not attached to a connection yet.");
                }
                return this._connection;
            }
            initialize(_capabilities) {}
            fillServerCapabilities(_capabilities) {}
            applyEdit(paramOrEdit) {
                function isApplyWorkspaceEditParams(value1) {
                    return value1 && !!value1.edit;
                }
                let params = isApplyWorkspaceEditParams(paramOrEdit) ? paramOrEdit : {
                    edit: paramOrEdit
                };
                return this.connection.sendRequest(vscode_languageserver_protocol_1.ApplyWorkspaceEditRequest.type, params);
            }
            constructor(){}
        };
        var RemoteWorkspaceImpl = fileOperations_1.FileOperationsFeature(workspaceFolders_1.WorkspaceFoldersFeature(configuration_1.ConfigurationFeature(_RemoteWorkspaceImpl)));
        var TracerImpl = class {
            attach(connection) {
                this._connection = connection;
            }
            get connection() {
                if (!this._connection) {
                    throw new Error("Remote is not attached to a connection yet.");
                }
                return this._connection;
            }
            initialize(_capabilities) {}
            fillServerCapabilities(_capabilities) {}
            set trace(value1) {
                this._trace = value1;
            }
            log(message, verbose) {
                if (this._trace === vscode_languageserver_protocol_1.Trace.Off) {
                    return;
                }
                this.connection.sendNotification(vscode_languageserver_protocol_1.LogTraceNotification.type, {
                    message,
                    verbose: this._trace === vscode_languageserver_protocol_1.Trace.Verbose ? verbose : void 0
                });
            }
            constructor(){
                this._trace = vscode_languageserver_protocol_1.Trace.Off;
            }
        };
        var TelemetryImpl = class {
            attach(connection) {
                this._connection = connection;
            }
            get connection() {
                if (!this._connection) {
                    throw new Error("Remote is not attached to a connection yet.");
                }
                return this._connection;
            }
            initialize(_capabilities) {}
            fillServerCapabilities(_capabilities) {}
            logEvent(data) {
                this.connection.sendNotification(vscode_languageserver_protocol_1.TelemetryEventNotification.type, data);
            }
            constructor(){}
        };
        var _LanguagesImpl = class {
            attach(connection) {
                this._connection = connection;
            }
            get connection() {
                if (!this._connection) {
                    throw new Error("Remote is not attached to a connection yet.");
                }
                return this._connection;
            }
            initialize(_capabilities) {}
            fillServerCapabilities(_capabilities) {}
            attachWorkDoneProgress(params) {
                return progress_1.attachWorkDone(this.connection, params);
            }
            attachPartialResultProgress(_type, params) {
                return progress_1.attachPartialResult(this.connection, params);
            }
            constructor(){}
        };
        exports._LanguagesImpl = _LanguagesImpl;
        var LanguagesImpl = moniker_1.MonikerFeature(linkedEditingRange_1.LinkedEditingRangeFeature(semanticTokens_1.SemanticTokensFeature(callHierarchy_1.CallHierarchyFeature(_LanguagesImpl))));
        function combineConsoleFeatures(one, two) {
            return function(Base) {
                return two(one(Base));
            };
        }
        exports.combineConsoleFeatures = combineConsoleFeatures;
        function combineTelemetryFeatures(one, two) {
            return function(Base) {
                return two(one(Base));
            };
        }
        exports.combineTelemetryFeatures = combineTelemetryFeatures;
        function combineTracerFeatures(one, two) {
            return function(Base) {
                return two(one(Base));
            };
        }
        exports.combineTracerFeatures = combineTracerFeatures;
        function combineClientFeatures(one, two) {
            return function(Base) {
                return two(one(Base));
            };
        }
        exports.combineClientFeatures = combineClientFeatures;
        function combineWindowFeatures(one, two) {
            return function(Base) {
                return two(one(Base));
            };
        }
        exports.combineWindowFeatures = combineWindowFeatures;
        function combineWorkspaceFeatures(one, two) {
            return function(Base) {
                return two(one(Base));
            };
        }
        exports.combineWorkspaceFeatures = combineWorkspaceFeatures;
        function combineLanguagesFeatures(one, two) {
            return function(Base) {
                return two(one(Base));
            };
        }
        exports.combineLanguagesFeatures = combineLanguagesFeatures;
        function combineFeatures(one, two) {
            function combine(one2, two2, func) {
                if (one2 && two2) {
                    return func(one2, two2);
                } else if (one2) {
                    return one2;
                } else {
                    return two2;
                }
            }
            let result = {
                __brand: "features",
                console: combine(one.console, two.console, combineConsoleFeatures),
                tracer: combine(one.tracer, two.tracer, combineTracerFeatures),
                telemetry: combine(one.telemetry, two.telemetry, combineTelemetryFeatures),
                client: combine(one.client, two.client, combineClientFeatures),
                window: combine(one.window, two.window, combineWindowFeatures),
                workspace: combine(one.workspace, two.workspace, combineWorkspaceFeatures)
            };
            return result;
        }
        exports.combineFeatures = combineFeatures;
        function createConnection(connectionFactory, watchDog, factories) {
            const logger = factories && factories.console ? new (factories.console(RemoteConsoleImpl))() : new RemoteConsoleImpl();
            const connection = connectionFactory(logger);
            logger.rawAttach(connection);
            const tracer = factories && factories.tracer ? new (factories.tracer(TracerImpl))() : new TracerImpl();
            const telemetry = factories && factories.telemetry ? new (factories.telemetry(TelemetryImpl))() : new TelemetryImpl();
            const client = factories && factories.client ? new (factories.client(RemoteClientImpl))() : new RemoteClientImpl();
            const remoteWindow = factories && factories.window ? new (factories.window(RemoteWindowImpl))() : new RemoteWindowImpl();
            const workspace = factories && factories.workspace ? new (factories.workspace(RemoteWorkspaceImpl))() : new RemoteWorkspaceImpl();
            const languages = factories && factories.languages ? new (factories.languages(LanguagesImpl))() : new LanguagesImpl();
            const allRemotes = [
                logger,
                tracer,
                telemetry,
                client,
                remoteWindow,
                workspace,
                languages
            ];
            function asPromise(value1) {
                if (value1 instanceof Promise) {
                    return value1;
                } else if (Is.thenable(value1)) {
                    return new Promise((resolve2, reject)=>{
                        value1.then((resolved)=>resolve2(resolved), (error)=>reject(error));
                    });
                } else {
                    return Promise.resolve(value1);
                }
            }
            let shutdownHandler = void 0;
            let initializeHandler = void 0;
            let exitHandler = void 0;
            let protocolConnection = {
                listen: ()=>connection.listen(),
                sendRequest: (type, ...params)=>connection.sendRequest(Is.string(type) ? type : type.method, ...params),
                onRequest: (type, handler)=>connection.onRequest(type, handler),
                sendNotification: (type, param)=>{
                    const method = Is.string(type) ? type : type.method;
                    if (arguments.length === 1) {
                        connection.sendNotification(method);
                    } else {
                        connection.sendNotification(method, param);
                    }
                },
                onNotification: (type, handler)=>connection.onNotification(type, handler),
                onProgress: connection.onProgress,
                sendProgress: connection.sendProgress,
                onInitialize: (handler)=>initializeHandler = handler,
                onInitialized: (handler)=>connection.onNotification(vscode_languageserver_protocol_1.InitializedNotification.type, handler),
                onShutdown: (handler)=>shutdownHandler = handler,
                onExit: (handler)=>exitHandler = handler,
                get console () {
                    return logger;
                },
                get telemetry () {
                    return telemetry;
                },
                get tracer () {
                    return tracer;
                },
                get client () {
                    return client;
                },
                get window () {
                    return remoteWindow;
                },
                get workspace () {
                    return workspace;
                },
                get languages () {
                    return languages;
                },
                onDidChangeConfiguration: (handler)=>connection.onNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, handler),
                onDidChangeWatchedFiles: (handler)=>connection.onNotification(vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type, handler),
                __textDocumentSync: void 0,
                onDidOpenTextDocument: (handler)=>connection.onNotification(vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type, handler),
                onDidChangeTextDocument: (handler)=>connection.onNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, handler),
                onDidCloseTextDocument: (handler)=>connection.onNotification(vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type, handler),
                onWillSaveTextDocument: (handler)=>connection.onNotification(vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type, handler),
                onWillSaveTextDocumentWaitUntil: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type, handler),
                onDidSaveTextDocument: (handler)=>connection.onNotification(vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type, handler),
                sendDiagnostics: (params)=>connection.sendNotification(vscode_languageserver_protocol_1.PublishDiagnosticsNotification.type, params),
                onHover: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.HoverRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), void 0);
                    }),
                onCompletion: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.CompletionRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onCompletionResolve: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, handler),
                onSignatureHelp: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), void 0);
                    }),
                onDeclaration: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onDefinition: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onTypeDefinition: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onImplementation: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onReferences: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onDocumentHighlight: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onDocumentSymbol: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onWorkspaceSymbol: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onCodeAction: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.CodeActionRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onCodeActionResolve: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.CodeActionResolveRequest.type, (params, cancel)=>{
                        return handler(params, cancel);
                    }),
                onCodeLens: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onCodeLensResolve: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, (params, cancel)=>{
                        return handler(params, cancel);
                    }),
                onDocumentFormatting: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), void 0);
                    }),
                onDocumentRangeFormatting: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), void 0);
                    }),
                onDocumentOnTypeFormatting: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, (params, cancel)=>{
                        return handler(params, cancel);
                    }),
                onRenameRequest: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.RenameRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), void 0);
                    }),
                onPrepareRename: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.PrepareRenameRequest.type, (params, cancel)=>{
                        return handler(params, cancel);
                    }),
                onDocumentLinks: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onDocumentLinkResolve: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, (params, cancel)=>{
                        return handler(params, cancel);
                    }),
                onDocumentColor: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onColorPresentation: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onFoldingRanges: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onSelectionRanges: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), progress_1.attachPartialResult(connection, params));
                    }),
                onExecuteCommand: (handler)=>connection.onRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, (params, cancel)=>{
                        return handler(params, cancel, progress_1.attachWorkDone(connection, params), void 0);
                    }),
                dispose: ()=>connection.dispose()
            };
            for (let remote of allRemotes){
                remote.attach(protocolConnection);
            }
            connection.onRequest(vscode_languageserver_protocol_1.InitializeRequest.type, (params)=>{
                watchDog.initialize(params);
                if (Is.string(params.trace)) {
                    tracer.trace = vscode_languageserver_protocol_1.Trace.fromString(params.trace);
                }
                for (let remote of allRemotes){
                    remote.initialize(params.capabilities);
                }
                if (initializeHandler) {
                    let result = initializeHandler(params, new vscode_languageserver_protocol_1.CancellationTokenSource().token, progress_1.attachWorkDone(connection, params), void 0);
                    return asPromise(result).then((value1)=>{
                        if (value1 instanceof vscode_languageserver_protocol_1.ResponseError) {
                            return value1;
                        }
                        let result2 = value1;
                        if (!result2) {
                            result2 = {
                                capabilities: {}
                            };
                        }
                        let capabilities = result2.capabilities;
                        if (!capabilities) {
                            capabilities = {};
                            result2.capabilities = capabilities;
                        }
                        if (capabilities.textDocumentSync === void 0 || capabilities.textDocumentSync === null) {
                            capabilities.textDocumentSync = Is.number(protocolConnection.__textDocumentSync) ? protocolConnection.__textDocumentSync : vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
                        } else if (!Is.number(capabilities.textDocumentSync) && !Is.number(capabilities.textDocumentSync.change)) {
                            capabilities.textDocumentSync.change = Is.number(protocolConnection.__textDocumentSync) ? protocolConnection.__textDocumentSync : vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
                        }
                        for (let remote of allRemotes){
                            remote.fillServerCapabilities(capabilities);
                        }
                        return result2;
                    });
                } else {
                    let result = {
                        capabilities: {
                            textDocumentSync: vscode_languageserver_protocol_1.TextDocumentSyncKind.None
                        }
                    };
                    for (let remote of allRemotes){
                        remote.fillServerCapabilities(result.capabilities);
                    }
                    return result;
                }
            });
            connection.onRequest(vscode_languageserver_protocol_1.ShutdownRequest.type, ()=>{
                watchDog.shutdownReceived = true;
                if (shutdownHandler) {
                    return shutdownHandler(new vscode_languageserver_protocol_1.CancellationTokenSource().token);
                } else {
                    return void 0;
                }
            });
            connection.onNotification(vscode_languageserver_protocol_1.ExitNotification.type, ()=>{
                try {
                    if (exitHandler) {
                        exitHandler();
                    }
                } finally{
                    if (watchDog.shutdownReceived) {
                        watchDog.exit(0);
                    } else {
                        watchDog.exit(1);
                    }
                }
            });
            connection.onNotification(vscode_languageserver_protocol_1.SetTraceNotification.type, (params)=>{
                tracer.trace = vscode_languageserver_protocol_1.Trace.fromString(params.value);
            });
            return protocolConnection;
        }
        exports.createConnection = createConnection;
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/api.js
var require_api3 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/common/api.js" (exports) {
        "use strict";
        var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
            if (k2 === void 0) k2 = k;
            Object.defineProperty(o, k2, {
                enumerable: true,
                get: function() {
                    return m[k];
                }
            });
        } : function(o, m, k, k2) {
            if (k2 === void 0) k2 = k;
            o[k2] = m[k];
        });
        var __exportStar = exports && exports.__exportStar || function(m, exports2) {
            for(var p in m)if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
        };
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.ProposedFeatures = exports.SemanticTokensBuilder = void 0;
        var semanticTokens_1 = require_semanticTokens();
        Object.defineProperty(exports, "SemanticTokensBuilder", {
            enumerable: true,
            get: function() {
                return semanticTokens_1.SemanticTokensBuilder;
            }
        });
        __exportStar(require_main3(), exports);
        __exportStar(require_server(), exports);
        var ProposedFeatures;
        (function(ProposedFeatures2) {
            ProposedFeatures2.all = {
                __brand: "features"
            };
        })(ProposedFeatures = exports.ProposedFeatures || (exports.ProposedFeatures = {}));
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/browser.js
var require_browser2 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver-protocol/browser.js" (exports, module) {
        "use strict";
        module.exports = require_main3();
    }
});
// ../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/browser/main.js
var require_main4 = __commonJS({
    "../../node_modules/yaml-language-server/node_modules/vscode-languageserver/lib/browser/main.js" (exports) {
        "use strict";
        var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
            if (k2 === void 0) k2 = k;
            Object.defineProperty(o, k2, {
                enumerable: true,
                get: function() {
                    return m[k];
                }
            });
        } : function(o, m, k, k2) {
            if (k2 === void 0) k2 = k;
            o[k2] = m[k];
        });
        var __exportStar = exports && exports.__exportStar || function(m, exports2) {
            for(var p in m)if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
        };
        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports.createConnection = void 0;
        var api_1 = require_api3();
        __exportStar(require_browser2(), exports);
        __exportStar(require_api3(), exports);
        var _shutdownReceived = false;
        var watchDog = {
            initialize: (_params)=>{},
            get shutdownReceived () {
                return _shutdownReceived;
            },
            set shutdownReceived (value){
                _shutdownReceived = value;
            },
            exit: (_code)=>{}
        };
        function createConnection(arg1, arg2, arg3, arg4) {
            let factories;
            let reader;
            let writer;
            let options;
            if (arg1 !== void 0 && arg1.__brand === "features") {
                factories = arg1;
                arg1 = arg2;
                arg2 = arg3;
                arg3 = arg4;
            }
            if (api_1.ConnectionStrategy.is(arg1) || api_1.ConnectionOptions.is(arg1)) {
                options = arg1;
            } else {
                reader = arg1;
                writer = arg2;
                options = arg3;
            }
            const connectionFactory = (logger)=>{
                return api_1.createProtocolConnection(reader, writer, logger, options);
            };
            return api_1.createConnection(connectionFactory, watchDog, factories);
        }
        exports.createConnection = createConnection;
    }
});
// ../../node_modules/jsonc-parser/lib/esm/impl/scanner.js
function createScanner(text, ignoreTrivia = false) {
    const len = text.length;
    let pos = 0, value1 = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
    function scanHexDigits(count, exact) {
        let digits = 0;
        let value2 = 0;
        while(digits < count || !exact){
            let ch = text.charCodeAt(pos);
            if (ch >= 48 && ch <= 57) {
                value2 = value2 * 16 + ch - 48;
            } else if (ch >= 65 && ch <= 70) {
                value2 = value2 * 16 + ch - 65 + 10;
            } else if (ch >= 97 && ch <= 102) {
                value2 = value2 * 16 + ch - 97 + 10;
            } else {
                break;
            }
            pos++;
            digits++;
        }
        if (digits < count) {
            value2 = -1;
        }
        return value2;
    }
    function setPosition(newPosition) {
        pos = newPosition;
        value1 = "";
        tokenOffset = 0;
        token = 16;
        scanError = 0;
    }
    function scanNumber() {
        let start = pos;
        if (text.charCodeAt(pos) === 48) {
            pos++;
        } else {
            pos++;
            while(pos < text.length && isDigit(text.charCodeAt(pos))){
                pos++;
            }
        }
        if (pos < text.length && text.charCodeAt(pos) === 46) {
            pos++;
            if (pos < text.length && isDigit(text.charCodeAt(pos))) {
                pos++;
                while(pos < text.length && isDigit(text.charCodeAt(pos))){
                    pos++;
                }
            } else {
                scanError = 3;
                return text.substring(start, pos);
            }
        }
        let end = pos;
        if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
            pos++;
            if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
                pos++;
            }
            if (pos < text.length && isDigit(text.charCodeAt(pos))) {
                pos++;
                while(pos < text.length && isDigit(text.charCodeAt(pos))){
                    pos++;
                }
                end = pos;
            } else {
                scanError = 3;
            }
        }
        return text.substring(start, end);
    }
    function scanString() {
        let result = "", start = pos;
        while(true){
            if (pos >= len) {
                result += text.substring(start, pos);
                scanError = 2;
                break;
            }
            const ch = text.charCodeAt(pos);
            if (ch === 34) {
                result += text.substring(start, pos);
                pos++;
                break;
            }
            if (ch === 92) {
                result += text.substring(start, pos);
                pos++;
                if (pos >= len) {
                    scanError = 2;
                    break;
                }
                const ch2 = text.charCodeAt(pos++);
                switch(ch2){
                    case 34:
                        result += '"';
                        break;
                    case 92:
                        result += "\\";
                        break;
                    case 47:
                        result += "/";
                        break;
                    case 98:
                        result += "\b";
                        break;
                    case 102:
                        result += "\f";
                        break;
                    case 110:
                        result += "\n";
                        break;
                    case 114:
                        result += "\r";
                        break;
                    case 116:
                        result += "	";
                        break;
                    case 117:
                        const ch3 = scanHexDigits(4, true);
                        if (ch3 >= 0) {
                            result += String.fromCharCode(ch3);
                        } else {
                            scanError = 4;
                        }
                        break;
                    default:
                        scanError = 5;
                }
                start = pos;
                continue;
            }
            if (ch >= 0 && ch <= 31) {
                if (isLineBreak(ch)) {
                    result += text.substring(start, pos);
                    scanError = 2;
                    break;
                } else {
                    scanError = 6;
                }
            }
            pos++;
        }
        return result;
    }
    function scanNext() {
        value1 = "";
        scanError = 0;
        tokenOffset = pos;
        lineStartOffset = lineNumber;
        prevTokenLineStartOffset = tokenLineStartOffset;
        if (pos >= len) {
            tokenOffset = len;
            return token = 17;
        }
        let code = text.charCodeAt(pos);
        if (isWhiteSpace(code)) {
            do {
                pos++;
                value1 += String.fromCharCode(code);
                code = text.charCodeAt(pos);
            }while (isWhiteSpace(code))
            return token = 15;
        }
        if (isLineBreak(code)) {
            pos++;
            value1 += String.fromCharCode(code);
            if (code === 13 && text.charCodeAt(pos) === 10) {
                pos++;
                value1 += "\n";
            }
            lineNumber++;
            tokenLineStartOffset = pos;
            return token = 14;
        }
        switch(code){
            case 123:
                pos++;
                return token = 1;
            case 125:
                pos++;
                return token = 2;
            case 91:
                pos++;
                return token = 3;
            case 93:
                pos++;
                return token = 4;
            case 58:
                pos++;
                return token = 6;
            case 44:
                pos++;
                return token = 5;
            case 34:
                pos++;
                value1 = scanString();
                return token = 10;
            case 47:
                const start = pos - 1;
                if (text.charCodeAt(pos + 1) === 47) {
                    pos += 2;
                    while(pos < len){
                        if (isLineBreak(text.charCodeAt(pos))) {
                            break;
                        }
                        pos++;
                    }
                    value1 = text.substring(start, pos);
                    return token = 12;
                }
                if (text.charCodeAt(pos + 1) === 42) {
                    pos += 2;
                    const safeLength = len - 1;
                    let commentClosed = false;
                    while(pos < safeLength){
                        const ch = text.charCodeAt(pos);
                        if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
                            pos += 2;
                            commentClosed = true;
                            break;
                        }
                        pos++;
                        if (isLineBreak(ch)) {
                            if (ch === 13 && text.charCodeAt(pos) === 10) {
                                pos++;
                            }
                            lineNumber++;
                            tokenLineStartOffset = pos;
                        }
                    }
                    if (!commentClosed) {
                        pos++;
                        scanError = 1;
                    }
                    value1 = text.substring(start, pos);
                    return token = 13;
                }
                value1 += String.fromCharCode(code);
                pos++;
                return token = 16;
            case 45:
                value1 += String.fromCharCode(code);
                pos++;
                if (pos === len || !isDigit(text.charCodeAt(pos))) {
                    return token = 16;
                }
            case 48:
            case 49:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
                value1 += scanNumber();
                return token = 11;
            default:
                while(pos < len && isUnknownContentCharacter(code)){
                    pos++;
                    code = text.charCodeAt(pos);
                }
                if (tokenOffset !== pos) {
                    value1 = text.substring(tokenOffset, pos);
                    switch(value1){
                        case "true":
                            return token = 8;
                        case "false":
                            return token = 9;
                        case "null":
                            return token = 7;
                    }
                    return token = 16;
                }
                value1 += String.fromCharCode(code);
                pos++;
                return token = 16;
        }
    }
    function isUnknownContentCharacter(code) {
        if (isWhiteSpace(code) || isLineBreak(code)) {
            return false;
        }
        switch(code){
            case 125:
            case 93:
            case 123:
            case 91:
            case 34:
            case 58:
            case 44:
            case 47:
                return false;
        }
        return true;
    }
    function scanNextNonTrivia() {
        let result;
        do {
            result = scanNext();
        }while (result >= 12 && result <= 15)
        return result;
    }
    return {
        setPosition,
        getPosition: ()=>pos,
        scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
        getToken: ()=>token,
        getTokenValue: ()=>value1,
        getTokenOffset: ()=>tokenOffset,
        getTokenLength: ()=>pos - tokenOffset,
        getTokenStartLine: ()=>lineStartOffset,
        getTokenStartCharacter: ()=>tokenOffset - prevTokenLineStartOffset,
        getTokenError: ()=>scanError
    };
}
function isWhiteSpace(ch) {
    return ch === 32 || ch === 9;
}
function isLineBreak(ch) {
    return ch === 10 || ch === 13;
}
function isDigit(ch) {
    return ch >= 48 && ch <= 57;
}
var CharacterCodes;
(function(CharacterCodes2) {
    CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
    CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
    CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
    CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
    CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
    CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
    CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
    CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
    CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
    CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
    CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
    CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
    CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
    CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
    CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
    CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
    CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
    CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
    CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
    CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
    CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
    CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
    CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
    CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
    CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
    CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
    CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
    CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
    CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
    CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
    CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
    CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
    CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
    CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
    CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
    CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
    CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
    CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
    CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
    CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
    CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
    CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
    CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
    CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
    CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
    CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
    CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
    CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
    CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
    CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
    CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
    CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
    CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
    CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
    CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
    CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
    CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
    CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
    CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
    CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
    CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
    CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
    CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
    CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
    CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
    CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
    CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
    CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
    CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
    CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
    CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
    CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
    CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
    CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
    CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
    CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
    CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
    CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
    CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
    CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
})(CharacterCodes || (CharacterCodes = {}));
// ../../node_modules/jsonc-parser/lib/esm/impl/string-intern.js
var cachedSpaces = new Array(20).fill(0).map((_2, index)=>{
    return " ".repeat(index);
});
var maxCachedValues = 200;
var cachedBreakLinesWithSpaces = {
    " ": {
        "\n": new Array(maxCachedValues).fill(0).map((_2, index)=>{
            return "\n" + " ".repeat(index);
        }),
        "\r": new Array(maxCachedValues).fill(0).map((_2, index)=>{
            return "\r" + " ".repeat(index);
        }),
        "\r\n": new Array(maxCachedValues).fill(0).map((_2, index)=>{
            return "\r\n" + " ".repeat(index);
        })
    },
    "	": {
        "\n": new Array(maxCachedValues).fill(0).map((_2, index)=>{
            return "\n" + "	".repeat(index);
        }),
        "\r": new Array(maxCachedValues).fill(0).map((_2, index)=>{
            return "\r" + "	".repeat(index);
        }),
        "\r\n": new Array(maxCachedValues).fill(0).map((_2, index)=>{
            return "\r\n" + "	".repeat(index);
        })
    }
};
// ../../node_modules/jsonc-parser/lib/esm/impl/parser.js
var ParseOptions;
(function(ParseOptions2) {
    ParseOptions2.DEFAULT = {
        allowTrailingComma: false
    };
})(ParseOptions || (ParseOptions = {}));
function parse(text, errors = [], options = ParseOptions.DEFAULT) {
    let currentProperty = null;
    let currentParent = [];
    const previousParents = [];
    function onValue(value1) {
        if (Array.isArray(currentParent)) {
            currentParent.push(value1);
        } else if (currentProperty !== null) {
            currentParent[currentProperty] = value1;
        }
    }
    const visitor = {
        onObjectBegin: ()=>{
            const object = {};
            onValue(object);
            previousParents.push(currentParent);
            currentParent = object;
            currentProperty = null;
        },
        onObjectProperty: (name)=>{
            currentProperty = name;
        },
        onObjectEnd: ()=>{
            currentParent = previousParents.pop();
        },
        onArrayBegin: ()=>{
            const array = [];
            onValue(array);
            previousParents.push(currentParent);
            currentParent = array;
            currentProperty = null;
        },
        onArrayEnd: ()=>{
            currentParent = previousParents.pop();
        },
        onLiteralValue: onValue,
        onError: (error, offset, length)=>{
            errors.push({
                error,
                offset,
                length
            });
        }
    };
    visit(text, visitor, options);
    return currentParent[0];
}
function getNodePath(node) {
    if (!node.parent || !node.parent.children) {
        return [];
    }
    const path5 = getNodePath(node.parent);
    if (node.parent.type === "property") {
        const key = node.parent.children[0].value;
        path5.push(key);
    } else if (node.parent.type === "array") {
        const index = node.parent.children.indexOf(node);
        if (index !== -1) {
            path5.push(index);
        }
    }
    return path5;
}
function getNodeValue(node) {
    switch(node.type){
        case "array":
            return node.children.map(getNodeValue);
        case "object":
            const obj = /* @__PURE__ */ Object.create(null);
            for (let prop of node.children){
                const valueNode = prop.children[1];
                if (valueNode) {
                    obj[prop.children[0].value] = getNodeValue(valueNode);
                }
            }
            return obj;
        case "null":
        case "string":
        case "number":
        case "boolean":
            return node.value;
        default:
            return void 0;
    }
}
function contains(node, offset, includeRightBound = false) {
    return offset >= node.offset && offset < node.offset + node.length || includeRightBound && offset === node.offset + node.length;
}
function findNodeAtOffset(node, offset, includeRightBound = false) {
    if (contains(node, offset, includeRightBound)) {
        const children = node.children;
        if (Array.isArray(children)) {
            for(let i = 0; i < children.length && children[i].offset <= offset; i++){
                const item = findNodeAtOffset(children[i], offset, includeRightBound);
                if (item) {
                    return item;
                }
            }
        }
        return node;
    }
    return void 0;
}
function visit(text, visitor, options = ParseOptions.DEFAULT) {
    const _scanner = createScanner(text, false);
    const _jsonPath = [];
    let suppressedCallbacks = 0;
    function toNoArgVisit(visitFunction) {
        return visitFunction ? ()=>suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : ()=>true;
    }
    function toOneArgVisit(visitFunction) {
        return visitFunction ? (arg)=>suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : ()=>true;
    }
    function toOneArgVisitWithPath(visitFunction) {
        return visitFunction ? (arg)=>suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), ()=>_jsonPath.slice()) : ()=>true;
    }
    function toBeginVisit(visitFunction) {
        return visitFunction ? ()=>{
            if (suppressedCallbacks > 0) {
                suppressedCallbacks++;
            } else {
                let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), ()=>_jsonPath.slice());
                if (cbReturn === false) {
                    suppressedCallbacks = 1;
                }
            }
        } : ()=>true;
    }
    function toEndVisit(visitFunction) {
        return visitFunction ? ()=>{
            if (suppressedCallbacks > 0) {
                suppressedCallbacks--;
            }
            if (suppressedCallbacks === 0) {
                visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
            }
        } : ()=>true;
    }
    const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
    const disallowComments = options && options.disallowComments;
    const allowTrailingComma = options && options.allowTrailingComma;
    function scanNext() {
        while(true){
            const token = _scanner.scan();
            switch(_scanner.getTokenError()){
                case 4:
                    handleError(14);
                    break;
                case 5:
                    handleError(15);
                    break;
                case 3:
                    handleError(13);
                    break;
                case 1:
                    if (!disallowComments) {
                        handleError(11);
                    }
                    break;
                case 2:
                    handleError(12);
                    break;
                case 6:
                    handleError(16);
                    break;
            }
            switch(token){
                case 12:
                case 13:
                    if (disallowComments) {
                        handleError(10);
                    } else {
                        onComment();
                    }
                    break;
                case 16:
                    handleError(1);
                    break;
                case 15:
                case 14:
                    break;
                default:
                    return token;
            }
        }
    }
    function handleError(error, skipUntilAfter = [], skipUntil = []) {
        onError(error);
        if (skipUntilAfter.length + skipUntil.length > 0) {
            let token = _scanner.getToken();
            while(token !== 17){
                if (skipUntilAfter.indexOf(token) !== -1) {
                    scanNext();
                    break;
                } else if (skipUntil.indexOf(token) !== -1) {
                    break;
                }
                token = scanNext();
            }
        }
    }
    function parseString(isValue) {
        const value1 = _scanner.getTokenValue();
        if (isValue) {
            onLiteralValue(value1);
        } else {
            onObjectProperty(value1);
            _jsonPath.push(value1);
        }
        scanNext();
        return true;
    }
    function parseLiteral() {
        switch(_scanner.getToken()){
            case 11:
                const tokenValue = _scanner.getTokenValue();
                let value1 = Number(tokenValue);
                if (isNaN(value1)) {
                    handleError(2);
                    value1 = 0;
                }
                onLiteralValue(value1);
                break;
            case 7:
                onLiteralValue(null);
                break;
            case 8:
                onLiteralValue(true);
                break;
            case 9:
                onLiteralValue(false);
                break;
            default:
                return false;
        }
        scanNext();
        return true;
    }
    function parseProperty() {
        if (_scanner.getToken() !== 10) {
            handleError(3, [], [
                2,
                5
            ]);
            return false;
        }
        parseString(false);
        if (_scanner.getToken() === 6) {
            onSeparator(":");
            scanNext();
            if (!parseValue()) {
                handleError(4, [], [
                    2,
                    5
                ]);
            }
        } else {
            handleError(5, [], [
                2,
                5
            ]);
        }
        _jsonPath.pop();
        return true;
    }
    function parseObject() {
        onObjectBegin();
        scanNext();
        let needsComma = false;
        while(_scanner.getToken() !== 2 && _scanner.getToken() !== 17){
            if (_scanner.getToken() === 5) {
                if (!needsComma) {
                    handleError(4, [], []);
                }
                onSeparator(",");
                scanNext();
                if (_scanner.getToken() === 2 && allowTrailingComma) {
                    break;
                }
            } else if (needsComma) {
                handleError(6, [], []);
            }
            if (!parseProperty()) {
                handleError(4, [], [
                    2,
                    5
                ]);
            }
            needsComma = true;
        }
        onObjectEnd();
        if (_scanner.getToken() !== 2) {
            handleError(7, [
                2
            ], []);
        } else {
            scanNext();
        }
        return true;
    }
    function parseArray() {
        onArrayBegin();
        scanNext();
        let isFirstElement = true;
        let needsComma = false;
        while(_scanner.getToken() !== 4 && _scanner.getToken() !== 17){
            if (_scanner.getToken() === 5) {
                if (!needsComma) {
                    handleError(4, [], []);
                }
                onSeparator(",");
                scanNext();
                if (_scanner.getToken() === 4 && allowTrailingComma) {
                    break;
                }
            } else if (needsComma) {
                handleError(6, [], []);
            }
            if (isFirstElement) {
                _jsonPath.push(0);
                isFirstElement = false;
            } else {
                _jsonPath[_jsonPath.length - 1]++;
            }
            if (!parseValue()) {
                handleError(4, [], [
                    4,
                    5
                ]);
            }
            needsComma = true;
        }
        onArrayEnd();
        if (!isFirstElement) {
            _jsonPath.pop();
        }
        if (_scanner.getToken() !== 4) {
            handleError(8, [
                4
            ], []);
        } else {
            scanNext();
        }
        return true;
    }
    function parseValue() {
        switch(_scanner.getToken()){
            case 3:
                return parseArray();
            case 1:
                return parseObject();
            case 10:
                return parseString(true);
            default:
                return parseLiteral();
        }
    }
    scanNext();
    if (_scanner.getToken() === 17) {
        if (options.allowEmptyContent) {
            return true;
        }
        handleError(4, [], []);
        return false;
    }
    if (!parseValue()) {
        handleError(4, [], []);
        return false;
    }
    if (_scanner.getToken() !== 17) {
        handleError(9, [], []);
    }
    return true;
}
// ../../node_modules/jsonc-parser/lib/esm/main.js
var createScanner2 = createScanner;
var ScanError;
(function(ScanError2) {
    ScanError2[ScanError2["None"] = 0] = "None";
    ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
    ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
    ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
    ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
    ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
    ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
})(ScanError || (ScanError = {}));
var SyntaxKind;
(function(SyntaxKind2) {
    SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
    SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
    SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
    SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
    SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
    SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
    SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
    SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
    SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
    SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
    SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
    SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
    SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
    SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
    SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
    SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
    SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
})(SyntaxKind || (SyntaxKind = {}));
var parse2 = parse;
var findNodeAtOffset2 = findNodeAtOffset;
var getNodePath2 = getNodePath;
var getNodeValue2 = getNodeValue;
var ParseErrorCode;
(function(ParseErrorCode2) {
    ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
    ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
    ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
    ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
    ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
    ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
    ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
    ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
    ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
    ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
    ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
    ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
    ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
    ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
    ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
    ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
})(ParseErrorCode || (ParseErrorCode = {}));
// ../../node_modules/vscode-uri/lib/esm/index.mjs
var LIB;
(()=>{
    "use strict";
    var t1 = {
        470: (t2)=>{
            function e2(t3) {
                if ("string" != typeof t3) throw new TypeError("Path must be a string. Received " + JSON.stringify(t3));
            }
            function r2(t3, e3) {
                for(var r3, n3 = "", i = 0, o = -1, s = 0, h = 0; h <= t3.length; ++h){
                    if (h < t3.length) r3 = t3.charCodeAt(h);
                    else {
                        if (47 === r3) break;
                        r3 = 47;
                    }
                    if (47 === r3) {
                        if (o === h - 1 || 1 === s) ;
                        else if (o !== h - 1 && 2 === s) {
                            if (n3.length < 2 || 2 !== i || 46 !== n3.charCodeAt(n3.length - 1) || 46 !== n3.charCodeAt(n3.length - 2)) {
                                if (n3.length > 2) {
                                    var a2 = n3.lastIndexOf("/");
                                    if (a2 !== n3.length - 1) {
                                        -1 === a2 ? (n3 = "", i = 0) : i = (n3 = n3.slice(0, a2)).length - 1 - n3.lastIndexOf("/"), o = h, s = 0;
                                        continue;
                                    }
                                } else if (2 === n3.length || 1 === n3.length) {
                                    n3 = "", i = 0, o = h, s = 0;
                                    continue;
                                }
                            }
                            e3 && (n3.length > 0 ? n3 += "/.." : n3 = "..", i = 2);
                        } else n3.length > 0 ? n3 += "/" + t3.slice(o + 1, h) : n3 = t3.slice(o + 1, h), i = h - o - 1;
                        o = h, s = 0;
                    } else 46 === r3 && -1 !== s ? ++s : s = -1;
                }
                return n3;
            }
            var n2 = {
                resolve: function() {
                    for(var t3, n3 = "", i = false, o = arguments.length - 1; o >= -1 && !i; o--){
                        var s;
                        o >= 0 ? s = arguments[o] : (void 0 === t3 && (t3 = process.cwd()), s = t3), e2(s), 0 !== s.length && (n3 = s + "/" + n3, i = 47 === s.charCodeAt(0));
                    }
                    return n3 = r2(n3, !i), i ? n3.length > 0 ? "/" + n3 : "/" : n3.length > 0 ? n3 : ".";
                },
                normalize: function(t3) {
                    if (e2(t3), 0 === t3.length) return ".";
                    var n3 = 47 === t3.charCodeAt(0), i = 47 === t3.charCodeAt(t3.length - 1);
                    return 0 !== (t3 = r2(t3, !n3)).length || n3 || (t3 = "."), t3.length > 0 && i && (t3 += "/"), n3 ? "/" + t3 : t3;
                },
                isAbsolute: function(t3) {
                    return e2(t3), t3.length > 0 && 47 === t3.charCodeAt(0);
                },
                join: function() {
                    if (0 === arguments.length) return ".";
                    for(var t3, r3 = 0; r3 < arguments.length; ++r3){
                        var i = arguments[r3];
                        e2(i), i.length > 0 && (void 0 === t3 ? t3 = i : t3 += "/" + i);
                    }
                    return void 0 === t3 ? "." : n2.normalize(t3);
                },
                relative: function(t3, r3) {
                    if (e2(t3), e2(r3), t3 === r3) return "";
                    if ((t3 = n2.resolve(t3)) === (r3 = n2.resolve(r3))) return "";
                    for(var i = 1; i < t3.length && 47 === t3.charCodeAt(i); ++i);
                    for(var o = t3.length, s = o - i, h = 1; h < r3.length && 47 === r3.charCodeAt(h); ++h);
                    for(var a2 = r3.length - h, c = s < a2 ? s : a2, f2 = -1, u = 0; u <= c; ++u){
                        if (u === c) {
                            if (a2 > c) {
                                if (47 === r3.charCodeAt(h + u)) return r3.slice(h + u + 1);
                                if (0 === u) return r3.slice(h + u);
                            } else s > c && (47 === t3.charCodeAt(i + u) ? f2 = u : 0 === u && (f2 = 0));
                            break;
                        }
                        var l = t3.charCodeAt(i + u);
                        if (l !== r3.charCodeAt(h + u)) break;
                        47 === l && (f2 = u);
                    }
                    var g = "";
                    for(u = i + f2 + 1; u <= o; ++u)u !== o && 47 !== t3.charCodeAt(u) || (0 === g.length ? g += ".." : g += "/..");
                    return g.length > 0 ? g + r3.slice(h + f2) : (h += f2, 47 === r3.charCodeAt(h) && ++h, r3.slice(h));
                },
                _makeLong: function(t3) {
                    return t3;
                },
                dirname: function(t3) {
                    if (e2(t3), 0 === t3.length) return ".";
                    for(var r3 = t3.charCodeAt(0), n3 = 47 === r3, i = -1, o = true, s = t3.length - 1; s >= 1; --s)if (47 === (r3 = t3.charCodeAt(s))) {
                        if (!o) {
                            i = s;
                            break;
                        }
                    } else o = false;
                    return -1 === i ? n3 ? "/" : "." : n3 && 1 === i ? "//" : t3.slice(0, i);
                },
                basename: function(t3, r3) {
                    if (void 0 !== r3 && "string" != typeof r3) throw new TypeError('"ext" argument must be a string');
                    e2(t3);
                    var n3, i = 0, o = -1, s = true;
                    if (void 0 !== r3 && r3.length > 0 && r3.length <= t3.length) {
                        if (r3.length === t3.length && r3 === t3) return "";
                        var h = r3.length - 1, a2 = -1;
                        for(n3 = t3.length - 1; n3 >= 0; --n3){
                            var c = t3.charCodeAt(n3);
                            if (47 === c) {
                                if (!s) {
                                    i = n3 + 1;
                                    break;
                                }
                            } else -1 === a2 && (s = false, a2 = n3 + 1), h >= 0 && (c === r3.charCodeAt(h) ? -1 == --h && (o = n3) : (h = -1, o = a2));
                        }
                        return i === o ? o = a2 : -1 === o && (o = t3.length), t3.slice(i, o);
                    }
                    for(n3 = t3.length - 1; n3 >= 0; --n3)if (47 === t3.charCodeAt(n3)) {
                        if (!s) {
                            i = n3 + 1;
                            break;
                        }
                    } else -1 === o && (s = false, o = n3 + 1);
                    return -1 === o ? "" : t3.slice(i, o);
                },
                extname: function(t3) {
                    e2(t3);
                    for(var r3 = -1, n3 = 0, i = -1, o = true, s = 0, h = t3.length - 1; h >= 0; --h){
                        var a2 = t3.charCodeAt(h);
                        if (47 !== a2) -1 === i && (o = false, i = h + 1), 46 === a2 ? -1 === r3 ? r3 = h : 1 !== s && (s = 1) : -1 !== r3 && (s = -1);
                        else if (!o) {
                            n3 = h + 1;
                            break;
                        }
                    }
                    return -1 === r3 || -1 === i || 0 === s || 1 === s && r3 === i - 1 && r3 === n3 + 1 ? "" : t3.slice(r3, i);
                },
                format: function(t3) {
                    if (null === t3 || "object" != typeof t3) throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof t3);
                    return function(t4, e3) {
                        var r3 = e3.dir || e3.root, n3 = e3.base || (e3.name || "") + (e3.ext || "");
                        return r3 ? r3 === e3.root ? r3 + n3 : r3 + "/" + n3 : n3;
                    }(0, t3);
                },
                parse: function(t3) {
                    e2(t3);
                    var r3 = {
                        root: "",
                        dir: "",
                        base: "",
                        ext: "",
                        name: ""
                    };
                    if (0 === t3.length) return r3;
                    var n3, i = t3.charCodeAt(0), o = 47 === i;
                    o ? (r3.root = "/", n3 = 1) : n3 = 0;
                    for(var s = -1, h = 0, a2 = -1, c = true, f2 = t3.length - 1, u = 0; f2 >= n3; --f2)if (47 !== (i = t3.charCodeAt(f2))) -1 === a2 && (c = false, a2 = f2 + 1), 46 === i ? -1 === s ? s = f2 : 1 !== u && (u = 1) : -1 !== s && (u = -1);
                    else if (!c) {
                        h = f2 + 1;
                        break;
                    }
                    return -1 === s || -1 === a2 || 0 === u || 1 === u && s === a2 - 1 && s === h + 1 ? -1 !== a2 && (r3.base = r3.name = 0 === h && o ? t3.slice(1, a2) : t3.slice(h, a2)) : (0 === h && o ? (r3.name = t3.slice(1, s), r3.base = t3.slice(1, a2)) : (r3.name = t3.slice(h, s), r3.base = t3.slice(h, a2)), r3.ext = t3.slice(s, a2)), h > 0 ? r3.dir = t3.slice(0, h - 1) : o && (r3.dir = "/"), r3;
                },
                sep: "/",
                delimiter: ":",
                win32: null,
                posix: null
            };
            n2.posix = n2, t2.exports = n2;
        }
    }, e = {};
    function r(n2) {
        var i = e[n2];
        if (void 0 !== i) return i.exports;
        var o = e[n2] = {
            exports: {}
        };
        return t1[n2](o, o.exports, r), o.exports;
    }
    r.d = (t2, e2)=>{
        for(var n2 in e2)r.o(e2, n2) && !r.o(t2, n2) && Object.defineProperty(t2, n2, {
            enumerable: true,
            get: e2[n2]
        });
    }, r.o = (t2, e2)=>Object.prototype.hasOwnProperty.call(t2, e2), r.r = (t2)=>{
        "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(t2, Symbol.toStringTag, {
            value: "Module"
        }), Object.defineProperty(t2, "__esModule", {
            value: true
        });
    };
    var n = {};
    (()=>{
        let t2;
        if (r.r(n), r.d(n, {
            URI: ()=>f2,
            Utils: ()=>P
        }), "object" == typeof process) t2 = "win32" === process.platform;
        else if ("object" == typeof navigator) {
            let e3 = navigator.userAgent;
            t2 = e3.indexOf("Windows") >= 0;
        }
        const e2 = /^\w[\w\d+.-]*$/, i = /^\//, o = /^\/\//;
        function s(t3, r2) {
            if (!t3.scheme && r2) throw new Error(`[UriError]: Scheme is missing: {scheme: "", authority: "${t3.authority}", path: "${t3.path}", query: "${t3.query}", fragment: "${t3.fragment}"}`);
            if (t3.scheme && !e2.test(t3.scheme)) throw new Error("[UriError]: Scheme contains illegal characters.");
            if (t3.path) {
                if (t3.authority) {
                    if (!i.test(t3.path)) throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash ("/") character');
                } else if (o.test(t3.path)) throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")');
            }
        }
        const h = "", a2 = "/", c = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
        class f2 {
            static isUri(t3) {
                return t3 instanceof f2 || !!t3 && "string" == typeof t3.authority && "string" == typeof t3.fragment && "string" == typeof t3.path && "string" == typeof t3.query && "string" == typeof t3.scheme && "string" == typeof t3.fsPath && "function" == typeof t3.with && "function" == typeof t3.toString;
            }
            get fsPath() {
                return m(this, false);
            }
            with(t3) {
                if (!t3) return this;
                let { scheme: e3, authority: r2, path: n2, query: i2, fragment: o2 } = t3;
                return void 0 === e3 ? e3 = this.scheme : null === e3 && (e3 = h), void 0 === r2 ? r2 = this.authority : null === r2 && (r2 = h), void 0 === n2 ? n2 = this.path : null === n2 && (n2 = h), void 0 === i2 ? i2 = this.query : null === i2 && (i2 = h), void 0 === o2 ? o2 = this.fragment : null === o2 && (o2 = h), e3 === this.scheme && r2 === this.authority && n2 === this.path && i2 === this.query && o2 === this.fragment ? this : new l(e3, r2, n2, i2, o2);
            }
            static parse(t3, e3 = false) {
                const r2 = c.exec(t3);
                return r2 ? new l(r2[2] || h, C(r2[4] || h), C(r2[5] || h), C(r2[7] || h), C(r2[9] || h), e3) : new l(h, h, h, h, h);
            }
            static file(e3) {
                let r2 = h;
                if (t2 && (e3 = e3.replace(/\\/g, a2)), e3[0] === a2 && e3[1] === a2) {
                    const t3 = e3.indexOf(a2, 2);
                    -1 === t3 ? (r2 = e3.substring(2), e3 = a2) : (r2 = e3.substring(2, t3), e3 = e3.substring(t3) || a2);
                }
                return new l("file", r2, e3, h, h);
            }
            static from(t3) {
                const e3 = new l(t3.scheme, t3.authority, t3.path, t3.query, t3.fragment);
                return s(e3, true), e3;
            }
            toString(t3 = false) {
                return y(this, t3);
            }
            toJSON() {
                return this;
            }
            static revive(t3) {
                if (t3) {
                    if (t3 instanceof f2) return t3;
                    {
                        const e3 = new l(t3);
                        return e3._formatted = t3.external, e3._fsPath = t3._sep === u ? t3.fsPath : null, e3;
                    }
                }
                return t3;
            }
            constructor(t3, e3, r2, n2, i2, o2 = false){
                __publicField(this, "scheme");
                __publicField(this, "authority");
                __publicField(this, "path");
                __publicField(this, "query");
                __publicField(this, "fragment");
                "object" == typeof t3 ? (this.scheme = t3.scheme || h, this.authority = t3.authority || h, this.path = t3.path || h, this.query = t3.query || h, this.fragment = t3.fragment || h) : (this.scheme = /* @__PURE__ */ function(t4, e4) {
                    return t4 || e4 ? t4 : "file";
                }(t3, o2), this.authority = e3 || h, this.path = function(t4, e4) {
                    switch(t4){
                        case "https":
                        case "http":
                        case "file":
                            e4 ? e4[0] !== a2 && (e4 = a2 + e4) : e4 = a2;
                    }
                    return e4;
                }(this.scheme, r2 || h), this.query = n2 || h, this.fragment = i2 || h, s(this, o2));
            }
        }
        const u = t2 ? 1 : void 0;
        class l extends f2 {
            get fsPath() {
                return this._fsPath || (this._fsPath = m(this, false)), this._fsPath;
            }
            toString(t3 = false) {
                return t3 ? y(this, true) : (this._formatted || (this._formatted = y(this, false)), this._formatted);
            }
            toJSON() {
                const t3 = {
                    $mid: 1
                };
                return this._fsPath && (t3.fsPath = this._fsPath, t3._sep = u), this._formatted && (t3.external = this._formatted), this.path && (t3.path = this.path), this.scheme && (t3.scheme = this.scheme), this.authority && (t3.authority = this.authority), this.query && (t3.query = this.query), this.fragment && (t3.fragment = this.fragment), t3;
            }
            constructor(){
                super(...arguments);
                __publicField(this, "_formatted", null);
                __publicField(this, "_fsPath", null);
            }
        }
        const g = {
            58: "%3A",
            47: "%2F",
            63: "%3F",
            35: "%23",
            91: "%5B",
            93: "%5D",
            64: "%40",
            33: "%21",
            36: "%24",
            38: "%26",
            39: "%27",
            40: "%28",
            41: "%29",
            42: "%2A",
            43: "%2B",
            44: "%2C",
            59: "%3B",
            61: "%3D",
            32: "%20"
        };
        function d(t3, e3, r2) {
            let n2, i2 = -1;
            for(let o2 = 0; o2 < t3.length; o2++){
                const s2 = t3.charCodeAt(o2);
                if (s2 >= 97 && s2 <= 122 || s2 >= 65 && s2 <= 90 || s2 >= 48 && s2 <= 57 || 45 === s2 || 46 === s2 || 95 === s2 || 126 === s2 || e3 && 47 === s2 || r2 && 91 === s2 || r2 && 93 === s2 || r2 && 58 === s2) -1 !== i2 && (n2 += encodeURIComponent(t3.substring(i2, o2)), i2 = -1), void 0 !== n2 && (n2 += t3.charAt(o2));
                else {
                    void 0 === n2 && (n2 = t3.substr(0, o2));
                    const e4 = g[s2];
                    void 0 !== e4 ? (-1 !== i2 && (n2 += encodeURIComponent(t3.substring(i2, o2)), i2 = -1), n2 += e4) : -1 === i2 && (i2 = o2);
                }
            }
            return -1 !== i2 && (n2 += encodeURIComponent(t3.substring(i2))), void 0 !== n2 ? n2 : t3;
        }
        function p(t3) {
            let e3;
            for(let r2 = 0; r2 < t3.length; r2++){
                const n2 = t3.charCodeAt(r2);
                35 === n2 || 63 === n2 ? (void 0 === e3 && (e3 = t3.substr(0, r2)), e3 += g[n2]) : void 0 !== e3 && (e3 += t3[r2]);
            }
            return void 0 !== e3 ? e3 : t3;
        }
        function m(e3, r2) {
            let n2;
            return n2 = e3.authority && e3.path.length > 1 && "file" === e3.scheme ? `//${e3.authority}${e3.path}` : 47 === e3.path.charCodeAt(0) && (e3.path.charCodeAt(1) >= 65 && e3.path.charCodeAt(1) <= 90 || e3.path.charCodeAt(1) >= 97 && e3.path.charCodeAt(1) <= 122) && 58 === e3.path.charCodeAt(2) ? r2 ? e3.path.substr(1) : e3.path[1].toLowerCase() + e3.path.substr(2) : e3.path, t2 && (n2 = n2.replace(/\//g, "\\")), n2;
        }
        function y(t3, e3) {
            const r2 = e3 ? p : d;
            let n2 = "", { scheme: i2, authority: o2, path: s2, query: h2, fragment: c2 } = t3;
            if (i2 && (n2 += i2, n2 += ":"), (o2 || "file" === i2) && (n2 += a2, n2 += a2), o2) {
                let t4 = o2.indexOf("@");
                if (-1 !== t4) {
                    const e4 = o2.substr(0, t4);
                    o2 = o2.substr(t4 + 1), t4 = e4.lastIndexOf(":"), -1 === t4 ? n2 += r2(e4, false, false) : (n2 += r2(e4.substr(0, t4), false, false), n2 += ":", n2 += r2(e4.substr(t4 + 1), false, true)), n2 += "@";
                }
                o2 = o2.toLowerCase(), t4 = o2.lastIndexOf(":"), -1 === t4 ? n2 += r2(o2, false, true) : (n2 += r2(o2.substr(0, t4), false, true), n2 += o2.substr(t4));
            }
            if (s2) {
                if (s2.length >= 3 && 47 === s2.charCodeAt(0) && 58 === s2.charCodeAt(2)) {
                    const t4 = s2.charCodeAt(1);
                    t4 >= 65 && t4 <= 90 && (s2 = `/${String.fromCharCode(t4 + 32)}:${s2.substr(3)}`);
                } else if (s2.length >= 2 && 58 === s2.charCodeAt(1)) {
                    const t4 = s2.charCodeAt(0);
                    t4 >= 65 && t4 <= 90 && (s2 = `${String.fromCharCode(t4 + 32)}:${s2.substr(2)}`);
                }
                n2 += r2(s2, true, false);
            }
            return h2 && (n2 += "?", n2 += r2(h2, false, false)), c2 && (n2 += "#", n2 += e3 ? c2 : d(c2, false, false)), n2;
        }
        function v(t3) {
            try {
                return decodeURIComponent(t3);
            } catch  {
                return t3.length > 3 ? t3.substr(0, 3) + v(t3.substr(3)) : t3;
            }
        }
        const b = /(%[0-9A-Za-z][0-9A-Za-z])+/g;
        function C(t3) {
            return t3.match(b) ? t3.replace(b, (t4)=>v(t4)) : t3;
        }
        var A2 = r(470);
        const w = A2.posix || A2, x = "/";
        var P;
        !function(t3) {
            t3.joinPath = function(t4, ...e3) {
                return t4.with({
                    path: w.join(t4.path, ...e3)
                });
            }, t3.resolvePath = function(t4, ...e3) {
                let r2 = t4.path, n2 = false;
                r2[0] !== x && (r2 = x + r2, n2 = true);
                let i2 = w.resolve(r2, ...e3);
                return n2 && i2[0] === x && !t4.authority && (i2 = i2.substring(1)), t4.with({
                    path: i2
                });
            }, t3.dirname = function(t4) {
                if (0 === t4.path.length || t4.path === x) return t4;
                let e3 = w.dirname(t4.path);
                return 1 === e3.length && 46 === e3.charCodeAt(0) && (e3 = ""), t4.with({
                    path: e3
                });
            }, t3.basename = function(t4) {
                return w.basename(t4.path);
            }, t3.extname = function(t4) {
                return w.extname(t4.path);
            };
        }(P || (P = {}));
    })(), LIB = n;
})();
var { URI: yaml_service_URI, Utils } = LIB;
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/utils/strings.js
function startsWith(haystack, needle) {
    if (haystack.length < needle.length) {
        return false;
    }
    for(var i = 0; i < needle.length; i++){
        if (haystack[i] !== needle[i]) {
            return false;
        }
    }
    return true;
}
function endsWith(haystack, needle) {
    var diff = haystack.length - needle.length;
    if (diff > 0) {
        return haystack.lastIndexOf(needle) === diff;
    } else if (diff === 0) {
        return haystack === needle;
    } else {
        return false;
    }
}
function extendedRegExp(pattern) {
    if (startsWith(pattern, "(?i)")) {
        return new RegExp(pattern.substring(4), "i");
    } else {
        return new RegExp(pattern);
    }
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/utils/objects.js
function equals(one, other) {
    if (one === other) {
        return true;
    }
    if (one === null || one === void 0 || other === null || other === void 0) {
        return false;
    }
    if (typeof one !== typeof other) {
        return false;
    }
    if (typeof one !== "object") {
        return false;
    }
    if (Array.isArray(one) !== Array.isArray(other)) {
        return false;
    }
    var i, key;
    if (Array.isArray(one)) {
        if (one.length !== other.length) {
            return false;
        }
        for(i = 0; i < one.length; i++){
            if (!equals(one[i], other[i])) {
                return false;
            }
        }
    } else {
        var oneKeys = [];
        for(key in one){
            oneKeys.push(key);
        }
        oneKeys.sort();
        var otherKeys = [];
        for(key in other){
            otherKeys.push(key);
        }
        otherKeys.sort();
        if (!equals(oneKeys, otherKeys)) {
            return false;
        }
        for(i = 0; i < oneKeys.length; i++){
            if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {
                return false;
            }
        }
    }
    return true;
}
function isNumber(val) {
    return typeof val === "number";
}
function isDefined(val) {
    return typeof val !== "undefined";
}
function isBoolean(val) {
    return typeof val === "boolean";
}
function isString(val) {
    return typeof val === "string";
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/jsonLanguageTypes.js
var import_vscode_languageserver_types = __toESM(require_main());
// ../../node_modules/vscode-languageserver-textdocument/lib/esm/main.js
var FullTextDocument = class _FullTextDocument {
    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)) {
                const range = getWellformedRange(change.range);
                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);
                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 < 1e4) {
                        lineOffsets.splice(startLine + 1, endLine - startLine, ...addedLineOffsets);
                    } else {
                        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 = void 0;
            } else {
                throw new Error("Unknown change event received");
            }
        }
        this._version = version;
    }
    getLineOffsets() {
        if (this._lineOffsets === void 0) {
            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;
            }
        }
        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 && isEOL2(this._content.charCodeAt(offset - 1))){
            offset--;
        }
        return offset;
    }
    get lineCount() {
        return this.getLineOffsets().length;
    }
    static isIncremental(event) {
        const candidate = event;
        return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range !== void 0 && (candidate.rangeLength === void 0 || typeof candidate.rangeLength === "number");
    }
    static isFull(event) {
        const candidate = event;
        return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range === void 0 && candidate.rangeLength === void 0;
    }
    constructor(uri, languageId, version, content){
        this._uri = uri;
        this._languageId = languageId;
        this._version = version;
        this._content = content;
        this._lineOffsets = void 0;
    }
};
var TextDocument;
(function(TextDocument2) {
    function create(uri, languageId, version, content) {
        return new FullTextDocument(uri, languageId, version, content);
    }
    TextDocument2.create = create;
    function update(document2, changes, version) {
        if (document2 instanceof FullTextDocument) {
            document2.update(changes, version);
            return document2;
        } else {
            throw new Error("TextDocument.update: document must be created by TextDocument.create");
        }
    }
    TextDocument2.update = update;
    function applyEdits(document2, edits) {
        const text = document2.getText();
        const sortedEdits = mergeSort(edits.map(getWellformedEdit), (a2, b)=>{
            const diff = a2.range.start.line - b.range.start.line;
            if (diff === 0) {
                return a2.range.start.character - b.range.start.character;
            }
            return diff;
        });
        let lastModifiedOffset = 0;
        const spans = [];
        for (const e of sortedEdits){
            const startOffset = document2.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 = document2.offsetAt(e.range.end);
        }
        spans.push(text.substr(lastModifiedOffset));
        return spans.join("");
    }
    TextDocument2.applyEdits = applyEdits;
})(TextDocument || (TextDocument = {}));
function mergeSort(data, compare2) {
    if (data.length <= 1) {
        return data;
    }
    const p = data.length / 2 | 0;
    const left = data.slice(0, p);
    const right = data.slice(p);
    mergeSort(left, compare2);
    mergeSort(right, compare2);
    let leftIdx = 0;
    let rightIdx = 0;
    let i = 0;
    while(leftIdx < left.length && rightIdx < right.length){
        const ret = compare2(left[leftIdx], right[rightIdx]);
        if (ret <= 0) {
            data[i++] = left[leftIdx++];
        } else {
            data[i++] = right[rightIdx++];
        }
    }
    while(leftIdx < left.length){
        data[i++] = left[leftIdx++];
    }
    while(rightIdx < right.length){
        data[i++] = right[rightIdx++];
    }
    return data;
}
function computeLineOffsets(text, isAtLineStart, textOffset = 0) {
    const result = isAtLineStart ? [
        textOffset
    ] : [];
    for(let i = 0; i < text.length; i++){
        const ch = text.charCodeAt(i);
        if (isEOL2(ch)) {
            if (ch === 13 && i + 1 < text.length && text.charCodeAt(i + 1) === 10) {
                i++;
            }
            result.push(textOffset + i + 1);
        }
    }
    return result;
}
function isEOL2(char) {
    return char === 13 || char === 10;
}
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;
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/jsonLanguageTypes.js
var ErrorCode;
(function(ErrorCode2) {
    ErrorCode2[ErrorCode2["Undefined"] = 0] = "Undefined";
    ErrorCode2[ErrorCode2["EnumValueMismatch"] = 1] = "EnumValueMismatch";
    ErrorCode2[ErrorCode2["Deprecated"] = 2] = "Deprecated";
    ErrorCode2[ErrorCode2["UnexpectedEndOfComment"] = 257] = "UnexpectedEndOfComment";
    ErrorCode2[ErrorCode2["UnexpectedEndOfString"] = 258] = "UnexpectedEndOfString";
    ErrorCode2[ErrorCode2["UnexpectedEndOfNumber"] = 259] = "UnexpectedEndOfNumber";
    ErrorCode2[ErrorCode2["InvalidUnicode"] = 260] = "InvalidUnicode";
    ErrorCode2[ErrorCode2["InvalidEscapeCharacter"] = 261] = "InvalidEscapeCharacter";
    ErrorCode2[ErrorCode2["InvalidCharacter"] = 262] = "InvalidCharacter";
    ErrorCode2[ErrorCode2["PropertyExpected"] = 513] = "PropertyExpected";
    ErrorCode2[ErrorCode2["CommaExpected"] = 514] = "CommaExpected";
    ErrorCode2[ErrorCode2["ColonExpected"] = 515] = "ColonExpected";
    ErrorCode2[ErrorCode2["ValueExpected"] = 516] = "ValueExpected";
    ErrorCode2[ErrorCode2["CommaOrCloseBacketExpected"] = 517] = "CommaOrCloseBacketExpected";
    ErrorCode2[ErrorCode2["CommaOrCloseBraceExpected"] = 518] = "CommaOrCloseBraceExpected";
    ErrorCode2[ErrorCode2["TrailingComma"] = 519] = "TrailingComma";
    ErrorCode2[ErrorCode2["DuplicateKey"] = 520] = "DuplicateKey";
    ErrorCode2[ErrorCode2["CommentNotPermitted"] = 521] = "CommentNotPermitted";
    ErrorCode2[ErrorCode2["SchemaResolveError"] = 768] = "SchemaResolveError";
})(ErrorCode || (ErrorCode = {}));
var ClientCapabilities;
(function(ClientCapabilities2) {
    ClientCapabilities2.LATEST = {
        textDocument: {
            completion: {
                completionItem: {
                    documentationFormat: [
                        import_vscode_languageserver_types.MarkupKind.Markdown,
                        import_vscode_languageserver_types.MarkupKind.PlainText
                    ],
                    commitCharactersSupport: true
                }
            }
        }
    };
})(ClientCapabilities || (ClientCapabilities = {}));
// src/fillers/vscode-nls.js
function format2(message, args) {
    return args.length === 0 ? message : message.replace(/{(\d+)}/g, (match, rest)=>{
        const [index] = rest;
        return typeof args[index] === "undefined" ? match : args[index];
    });
}
function localize(key, message, ...args) {
    return format2(message, args);
}
function loadMessageBundle() {
    return localize;
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/parser/jsonParser.js
var __extends = /* @__PURE__ */ function() {
    var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf || ({
            __proto__: []
        }) instanceof Array && function(d2, b2) {
            d2.__proto__ = b2;
        } || function(d2, b2) {
            for(var p in b2)if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
        };
        return extendStatics(d, b);
    };
    return function(d, b) {
        if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() {
            this.constructor = d;
        }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
}();
var localize2 = loadMessageBundle();
var formats = {
    "color-hex": {
        errorMessage: localize2("colorHexFormatWarning", "Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA."),
        pattern: /^#([0-9A-Fa-f]{3,4}|([0-9A-Fa-f]{2}){3,4})$/
    },
    "date-time": {
        errorMessage: localize2("dateTimeFormatWarning", "String is not a RFC3339 date-time."),
        pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/i
    },
    "date": {
        errorMessage: localize2("dateFormatWarning", "String is not a RFC3339 date."),
        pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/i
    },
    "time": {
        errorMessage: localize2("timeFormatWarning", "String is not a RFC3339 time."),
        pattern: /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/i
    },
    "email": {
        errorMessage: localize2("emailFormatWarning", "String is not an e-mail address."),
        pattern: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
    }
};
var ASTNodeImpl = /** @class */ function() {
    function ASTNodeImpl3(parent, offset, length) {
        if (length === void 0) {
            length = 0;
        }
        this.offset = offset;
        this.length = length;
        this.parent = parent;
    }
    Object.defineProperty(ASTNodeImpl3.prototype, "children", {
        get: function() {
            return [];
        },
        enumerable: false,
        configurable: true
    });
    ASTNodeImpl3.prototype.toString = function() {
        return "type: " + this.type + " (" + this.offset + "/" + this.length + ")" + (this.parent ? " parent: {" + this.parent.toString() + "}" : "");
    };
    return ASTNodeImpl3;
}();
var NullASTNodeImpl = /** @class */ function(_super) {
    __extends(NullASTNodeImpl3, _super);
    function NullASTNodeImpl3(parent, offset) {
        var _this = _super.call(this, parent, offset) || this;
        _this.type = "null";
        _this.value = null;
        return _this;
    }
    return NullASTNodeImpl3;
}(ASTNodeImpl);
var BooleanASTNodeImpl = /** @class */ function(_super) {
    __extends(BooleanASTNodeImpl3, _super);
    function BooleanASTNodeImpl3(parent, boolValue, offset) {
        var _this = _super.call(this, parent, offset) || this;
        _this.type = "boolean";
        _this.value = boolValue;
        return _this;
    }
    return BooleanASTNodeImpl3;
}(ASTNodeImpl);
var ArrayASTNodeImpl = /** @class */ function(_super) {
    __extends(ArrayASTNodeImpl3, _super);
    function ArrayASTNodeImpl3(parent, offset) {
        var _this = _super.call(this, parent, offset) || this;
        _this.type = "array";
        _this.items = [];
        return _this;
    }
    Object.defineProperty(ArrayASTNodeImpl3.prototype, "children", {
        get: function() {
            return this.items;
        },
        enumerable: false,
        configurable: true
    });
    return ArrayASTNodeImpl3;
}(ASTNodeImpl);
var NumberASTNodeImpl = /** @class */ function(_super) {
    __extends(NumberASTNodeImpl3, _super);
    function NumberASTNodeImpl3(parent, offset) {
        var _this = _super.call(this, parent, offset) || this;
        _this.type = "number";
        _this.isInteger = true;
        _this.value = Number.NaN;
        return _this;
    }
    return NumberASTNodeImpl3;
}(ASTNodeImpl);
var StringASTNodeImpl = /** @class */ function(_super) {
    __extends(StringASTNodeImpl3, _super);
    function StringASTNodeImpl3(parent, offset, length) {
        var _this = _super.call(this, parent, offset, length) || this;
        _this.type = "string";
        _this.value = "";
        return _this;
    }
    return StringASTNodeImpl3;
}(ASTNodeImpl);
var PropertyASTNodeImpl = /** @class */ function(_super) {
    __extends(PropertyASTNodeImpl3, _super);
    function PropertyASTNodeImpl3(parent, offset, keyNode) {
        var _this = _super.call(this, parent, offset) || this;
        _this.type = "property";
        _this.colonOffset = -1;
        _this.keyNode = keyNode;
        return _this;
    }
    Object.defineProperty(PropertyASTNodeImpl3.prototype, "children", {
        get: function() {
            return this.valueNode ? [
                this.keyNode,
                this.valueNode
            ] : [
                this.keyNode
            ];
        },
        enumerable: false,
        configurable: true
    });
    return PropertyASTNodeImpl3;
}(ASTNodeImpl);
var ObjectASTNodeImpl = /** @class */ function(_super) {
    __extends(ObjectASTNodeImpl3, _super);
    function ObjectASTNodeImpl3(parent, offset) {
        var _this = _super.call(this, parent, offset) || this;
        _this.type = "object";
        _this.properties = [];
        return _this;
    }
    Object.defineProperty(ObjectASTNodeImpl3.prototype, "children", {
        get: function() {
            return this.properties;
        },
        enumerable: false,
        configurable: true
    });
    return ObjectASTNodeImpl3;
}(ASTNodeImpl);
function asSchema(schema4) {
    if (isBoolean(schema4)) {
        return schema4 ? {} : {
            "not": {}
        };
    }
    return schema4;
}
var EnumMatch;
(function(EnumMatch3) {
    EnumMatch3[EnumMatch3["Key"] = 0] = "Key";
    EnumMatch3[EnumMatch3["Enum"] = 1] = "Enum";
})(EnumMatch || (EnumMatch = {}));
var SchemaCollector = /** @class */ function() {
    function SchemaCollector3(focusOffset, exclude) {
        if (focusOffset === void 0) {
            focusOffset = -1;
        }
        this.focusOffset = focusOffset;
        this.exclude = exclude;
        this.schemas = [];
    }
    SchemaCollector3.prototype.add = function(schema4) {
        this.schemas.push(schema4);
    };
    SchemaCollector3.prototype.merge = function(other) {
        Array.prototype.push.apply(this.schemas, other.schemas);
    };
    SchemaCollector3.prototype.include = function(node) {
        return (this.focusOffset === -1 || contains2(node, this.focusOffset)) && node !== this.exclude;
    };
    SchemaCollector3.prototype.newSub = function() {
        return new SchemaCollector3(-1, this.exclude);
    };
    return SchemaCollector3;
}();
var NoOpSchemaCollector = /** @class */ function() {
    function NoOpSchemaCollector3() {}
    Object.defineProperty(NoOpSchemaCollector3.prototype, "schemas", {
        get: function() {
            return [];
        },
        enumerable: false,
        configurable: true
    });
    NoOpSchemaCollector3.prototype.add = function(schema4) {};
    NoOpSchemaCollector3.prototype.merge = function(other) {};
    NoOpSchemaCollector3.prototype.include = function(node) {
        return true;
    };
    NoOpSchemaCollector3.prototype.newSub = function() {
        return this;
    };
    NoOpSchemaCollector3.instance = new NoOpSchemaCollector3();
    return NoOpSchemaCollector3;
}();
var ValidationResult = /** @class */ function() {
    function ValidationResult3() {
        this.problems = [];
        this.propertiesMatches = 0;
        this.propertiesValueMatches = 0;
        this.primaryValueMatches = 0;
        this.enumValueMatch = false;
        this.enumValues = void 0;
    }
    ValidationResult3.prototype.hasProblems = function() {
        return !!this.problems.length;
    };
    ValidationResult3.prototype.mergeAll = function(validationResults) {
        for(var _i = 0, validationResults_1 = validationResults; _i < validationResults_1.length; _i++){
            var validationResult = validationResults_1[_i];
            this.merge(validationResult);
        }
    };
    ValidationResult3.prototype.merge = function(validationResult) {
        this.problems = this.problems.concat(validationResult.problems);
    };
    ValidationResult3.prototype.mergeEnumValues = function(validationResult) {
        if (!this.enumValueMatch && !validationResult.enumValueMatch && this.enumValues && validationResult.enumValues) {
            this.enumValues = this.enumValues.concat(validationResult.enumValues);
            for(var _i = 0, _a = this.problems; _i < _a.length; _i++){
                var error = _a[_i];
                if (error.code === ErrorCode.EnumValueMismatch) {
                    error.message = localize2("enumWarning", "Value is not accepted. Valid values: {0}.", this.enumValues.map(function(v) {
                        return JSON.stringify(v);
                    }).join(", "));
                }
            }
        }
    };
    ValidationResult3.prototype.mergePropertyMatch = function(propertyValidationResult) {
        this.merge(propertyValidationResult);
        this.propertiesMatches++;
        if (propertyValidationResult.enumValueMatch || !propertyValidationResult.hasProblems() && propertyValidationResult.propertiesMatches) {
            this.propertiesValueMatches++;
        }
        if (propertyValidationResult.enumValueMatch && propertyValidationResult.enumValues && propertyValidationResult.enumValues.length === 1) {
            this.primaryValueMatches++;
        }
    };
    ValidationResult3.prototype.compare = function(other) {
        var hasProblems = this.hasProblems();
        if (hasProblems !== other.hasProblems()) {
            return hasProblems ? -1 : 1;
        }
        if (this.enumValueMatch !== other.enumValueMatch) {
            return other.enumValueMatch ? -1 : 1;
        }
        if (this.primaryValueMatches !== other.primaryValueMatches) {
            return this.primaryValueMatches - other.primaryValueMatches;
        }
        if (this.propertiesValueMatches !== other.propertiesValueMatches) {
            return this.propertiesValueMatches - other.propertiesValueMatches;
        }
        return this.propertiesMatches - other.propertiesMatches;
    };
    return ValidationResult3;
}();
function getNodeValue3(node) {
    return getNodeValue2(node);
}
function getNodePath3(node) {
    return getNodePath2(node);
}
function contains2(node, offset, includeRightBound) {
    if (includeRightBound === void 0) {
        includeRightBound = false;
    }
    return offset >= node.offset && offset < node.offset + node.length || includeRightBound && offset === node.offset + node.length;
}
var JSONDocument = /** @class */ function() {
    function JSONDocument3(root, syntaxErrors, comments) {
        if (syntaxErrors === void 0) {
            syntaxErrors = [];
        }
        if (comments === void 0) {
            comments = [];
        }
        this.root = root;
        this.syntaxErrors = syntaxErrors;
        this.comments = comments;
    }
    JSONDocument3.prototype.getNodeFromOffset = function(offset, includeRightBound) {
        if (includeRightBound === void 0) {
            includeRightBound = false;
        }
        if (this.root) {
            return findNodeAtOffset2(this.root, offset, includeRightBound);
        }
        return void 0;
    };
    JSONDocument3.prototype.visit = function(visitor) {
        if (this.root) {
            var doVisit_1 = function(node) {
                var ctn = visitor(node);
                var children = node.children;
                if (Array.isArray(children)) {
                    for(var i = 0; i < children.length && ctn; i++){
                        ctn = doVisit_1(children[i]);
                    }
                }
                return ctn;
            };
            doVisit_1(this.root);
        }
    };
    JSONDocument3.prototype.validate = function(textDocument, schema4, severity) {
        if (severity === void 0) {
            severity = import_vscode_languageserver_types.DiagnosticSeverity.Warning;
        }
        if (this.root && schema4) {
            var validationResult = new ValidationResult();
            validate(this.root, schema4, validationResult, NoOpSchemaCollector.instance);
            return validationResult.problems.map(function(p) {
                var _a;
                var range = import_vscode_languageserver_types.Range.create(textDocument.positionAt(p.location.offset), textDocument.positionAt(p.location.offset + p.location.length));
                return import_vscode_languageserver_types.Diagnostic.create(range, p.message, (_a = p.severity) !== null && _a !== void 0 ? _a : severity, p.code);
            });
        }
        return void 0;
    };
    JSONDocument3.prototype.getMatchingSchemas = function(schema4, focusOffset, exclude) {
        if (focusOffset === void 0) {
            focusOffset = -1;
        }
        var matchingSchemas = new SchemaCollector(focusOffset, exclude);
        if (this.root && schema4) {
            validate(this.root, schema4, new ValidationResult(), matchingSchemas);
        }
        return matchingSchemas.schemas;
    };
    return JSONDocument3;
}();
function validate(n, schema4, validationResult, matchingSchemas) {
    if (!n || !matchingSchemas.include(n)) {
        return;
    }
    var node = n;
    switch(node.type){
        case "object":
            _validateObjectNode(node, schema4, validationResult, matchingSchemas);
            break;
        case "array":
            _validateArrayNode(node, schema4, validationResult, matchingSchemas);
            break;
        case "string":
            _validateStringNode(node, schema4, validationResult, matchingSchemas);
            break;
        case "number":
            _validateNumberNode(node, schema4, validationResult, matchingSchemas);
            break;
        case "property":
            return validate(node.valueNode, schema4, validationResult, matchingSchemas);
    }
    _validateNode();
    matchingSchemas.add({
        node,
        schema: schema4
    });
    function _validateNode() {
        function matchesType(type) {
            return node.type === type || type === "integer" && node.type === "number" && node.isInteger;
        }
        if (Array.isArray(schema4.type)) {
            if (!schema4.type.some(matchesType)) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: node.length
                    },
                    message: schema4.errorMessage || localize2("typeArrayMismatchWarning", "Incorrect type. Expected one of {0}.", schema4.type.join(", "))
                });
            }
        } else if (schema4.type) {
            if (!matchesType(schema4.type)) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: node.length
                    },
                    message: schema4.errorMessage || localize2("typeMismatchWarning", 'Incorrect type. Expected "{0}".', schema4.type)
                });
            }
        }
        if (Array.isArray(schema4.allOf)) {
            for(var _i = 0, _a = schema4.allOf; _i < _a.length; _i++){
                var subSchemaRef = _a[_i];
                validate(node, asSchema(subSchemaRef), validationResult, matchingSchemas);
            }
        }
        var notSchema = asSchema(schema4.not);
        if (notSchema) {
            var subValidationResult = new ValidationResult();
            var subMatchingSchemas = matchingSchemas.newSub();
            validate(node, notSchema, subValidationResult, subMatchingSchemas);
            if (!subValidationResult.hasProblems()) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: node.length
                    },
                    message: localize2("notSchemaWarning", "Matches a schema that is not allowed.")
                });
            }
            for(var _b = 0, _c = subMatchingSchemas.schemas; _b < _c.length; _b++){
                var ms = _c[_b];
                ms.inverted = !ms.inverted;
                matchingSchemas.add(ms);
            }
        }
        var testAlternatives = function(alternatives, maxOneMatch) {
            var matches = [];
            var bestMatch = void 0;
            for(var _i2 = 0, alternatives_1 = alternatives; _i2 < alternatives_1.length; _i2++){
                var subSchemaRef2 = alternatives_1[_i2];
                var subSchema = asSchema(subSchemaRef2);
                var subValidationResult2 = new ValidationResult();
                var subMatchingSchemas2 = matchingSchemas.newSub();
                validate(node, subSchema, subValidationResult2, subMatchingSchemas2);
                if (!subValidationResult2.hasProblems()) {
                    matches.push(subSchema);
                }
                if (!bestMatch) {
                    bestMatch = {
                        schema: subSchema,
                        validationResult: subValidationResult2,
                        matchingSchemas: subMatchingSchemas2
                    };
                } else {
                    if (!maxOneMatch && !subValidationResult2.hasProblems() && !bestMatch.validationResult.hasProblems()) {
                        bestMatch.matchingSchemas.merge(subMatchingSchemas2);
                        bestMatch.validationResult.propertiesMatches += subValidationResult2.propertiesMatches;
                        bestMatch.validationResult.propertiesValueMatches += subValidationResult2.propertiesValueMatches;
                    } else {
                        var compareResult = subValidationResult2.compare(bestMatch.validationResult);
                        if (compareResult > 0) {
                            bestMatch = {
                                schema: subSchema,
                                validationResult: subValidationResult2,
                                matchingSchemas: subMatchingSchemas2
                            };
                        } else if (compareResult === 0) {
                            bestMatch.matchingSchemas.merge(subMatchingSchemas2);
                            bestMatch.validationResult.mergeEnumValues(subValidationResult2);
                        }
                    }
                }
            }
            if (matches.length > 1 && maxOneMatch) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: 1
                    },
                    message: localize2("oneOfWarning", "Matches multiple schemas when only one must validate.")
                });
            }
            if (bestMatch) {
                validationResult.merge(bestMatch.validationResult);
                validationResult.propertiesMatches += bestMatch.validationResult.propertiesMatches;
                validationResult.propertiesValueMatches += bestMatch.validationResult.propertiesValueMatches;
                matchingSchemas.merge(bestMatch.matchingSchemas);
            }
            return matches.length;
        };
        if (Array.isArray(schema4.anyOf)) {
            testAlternatives(schema4.anyOf, false);
        }
        if (Array.isArray(schema4.oneOf)) {
            testAlternatives(schema4.oneOf, true);
        }
        var testBranch = function(schema5) {
            var subValidationResult2 = new ValidationResult();
            var subMatchingSchemas2 = matchingSchemas.newSub();
            validate(node, asSchema(schema5), subValidationResult2, subMatchingSchemas2);
            validationResult.merge(subValidationResult2);
            validationResult.propertiesMatches += subValidationResult2.propertiesMatches;
            validationResult.propertiesValueMatches += subValidationResult2.propertiesValueMatches;
            matchingSchemas.merge(subMatchingSchemas2);
        };
        var testCondition = function(ifSchema2, thenSchema, elseSchema) {
            var subSchema = asSchema(ifSchema2);
            var subValidationResult2 = new ValidationResult();
            var subMatchingSchemas2 = matchingSchemas.newSub();
            validate(node, subSchema, subValidationResult2, subMatchingSchemas2);
            matchingSchemas.merge(subMatchingSchemas2);
            if (!subValidationResult2.hasProblems()) {
                if (thenSchema) {
                    testBranch(thenSchema);
                }
            } else if (elseSchema) {
                testBranch(elseSchema);
            }
        };
        var ifSchema = asSchema(schema4.if);
        if (ifSchema) {
            testCondition(ifSchema, asSchema(schema4.then), asSchema(schema4.else));
        }
        if (Array.isArray(schema4.enum)) {
            var val = getNodeValue3(node);
            var enumValueMatch = false;
            for(var _d = 0, _e = schema4.enum; _d < _e.length; _d++){
                var e = _e[_d];
                if (equals(val, e)) {
                    enumValueMatch = true;
                    break;
                }
            }
            validationResult.enumValues = schema4.enum;
            validationResult.enumValueMatch = enumValueMatch;
            if (!enumValueMatch) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: node.length
                    },
                    code: ErrorCode.EnumValueMismatch,
                    message: schema4.errorMessage || localize2("enumWarning", "Value is not accepted. Valid values: {0}.", schema4.enum.map(function(v) {
                        return JSON.stringify(v);
                    }).join(", "))
                });
            }
        }
        if (isDefined(schema4.const)) {
            var val = getNodeValue3(node);
            if (!equals(val, schema4.const)) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: node.length
                    },
                    code: ErrorCode.EnumValueMismatch,
                    message: schema4.errorMessage || localize2("constWarning", "Value must be {0}.", JSON.stringify(schema4.const))
                });
                validationResult.enumValueMatch = false;
            } else {
                validationResult.enumValueMatch = true;
            }
            validationResult.enumValues = [
                schema4.const
            ];
        }
        if (schema4.deprecationMessage && node.parent) {
            validationResult.problems.push({
                location: {
                    offset: node.parent.offset,
                    length: node.parent.length
                },
                severity: import_vscode_languageserver_types.DiagnosticSeverity.Warning,
                message: schema4.deprecationMessage,
                code: ErrorCode.Deprecated
            });
        }
    }
    function _validateNumberNode(node2, schema5, validationResult2, matchingSchemas2) {
        var val = node2.value;
        function normalizeFloats(float3) {
            var _a;
            var parts = /^(-?\d+)(?:\.(\d+))?(?:e([-+]\d+))?$/.exec(float3.toString());
            return parts && {
                value: Number(parts[1] + (parts[2] || "")),
                multiplier: (((_a = parts[2]) === null || _a === void 0 ? void 0 : _a.length) || 0) - (parseInt(parts[3]) || 0)
            };
        }
        ;
        if (isNumber(schema5.multipleOf)) {
            var remainder = -1;
            if (Number.isInteger(schema5.multipleOf)) {
                remainder = val % schema5.multipleOf;
            } else {
                var normMultipleOf = normalizeFloats(schema5.multipleOf);
                var normValue = normalizeFloats(val);
                if (normMultipleOf && normValue) {
                    var multiplier = Math.pow(10, Math.abs(normValue.multiplier - normMultipleOf.multiplier));
                    if (normValue.multiplier < normMultipleOf.multiplier) {
                        normValue.value *= multiplier;
                    } else {
                        normMultipleOf.value *= multiplier;
                    }
                    remainder = normValue.value % normMultipleOf.value;
                }
            }
            if (remainder !== 0) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    message: localize2("multipleOfWarning", "Value is not divisible by {0}.", schema5.multipleOf)
                });
            }
        }
        function getExclusiveLimit(limit, exclusive) {
            if (isNumber(exclusive)) {
                return exclusive;
            }
            if (isBoolean(exclusive) && exclusive) {
                return limit;
            }
            return void 0;
        }
        function getLimit(limit, exclusive) {
            if (!isBoolean(exclusive) || !exclusive) {
                return limit;
            }
            return void 0;
        }
        var exclusiveMinimum = getExclusiveLimit(schema5.minimum, schema5.exclusiveMinimum);
        if (isNumber(exclusiveMinimum) && val <= exclusiveMinimum) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                message: localize2("exclusiveMinimumWarning", "Value is below the exclusive minimum of {0}.", exclusiveMinimum)
            });
        }
        var exclusiveMaximum = getExclusiveLimit(schema5.maximum, schema5.exclusiveMaximum);
        if (isNumber(exclusiveMaximum) && val >= exclusiveMaximum) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                message: localize2("exclusiveMaximumWarning", "Value is above the exclusive maximum of {0}.", exclusiveMaximum)
            });
        }
        var minimum = getLimit(schema5.minimum, schema5.exclusiveMinimum);
        if (isNumber(minimum) && val < minimum) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                message: localize2("minimumWarning", "Value is below the minimum of {0}.", minimum)
            });
        }
        var maximum = getLimit(schema5.maximum, schema5.exclusiveMaximum);
        if (isNumber(maximum) && val > maximum) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                message: localize2("maximumWarning", "Value is above the maximum of {0}.", maximum)
            });
        }
    }
    function _validateStringNode(node2, schema5, validationResult2, matchingSchemas2) {
        if (isNumber(schema5.minLength) && node2.value.length < schema5.minLength) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                message: localize2("minLengthWarning", "String is shorter than the minimum length of {0}.", schema5.minLength)
            });
        }
        if (isNumber(schema5.maxLength) && node2.value.length > schema5.maxLength) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                message: localize2("maxLengthWarning", "String is longer than the maximum length of {0}.", schema5.maxLength)
            });
        }
        if (isString(schema5.pattern)) {
            var regex = extendedRegExp(schema5.pattern);
            if (!regex.test(node2.value)) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    message: schema5.patternErrorMessage || schema5.errorMessage || localize2("patternWarning", 'String does not match the pattern of "{0}".', schema5.pattern)
                });
            }
        }
        if (schema5.format) {
            switch(schema5.format){
                case "uri":
                case "uri-reference":
                    {
                        var errorMessage = void 0;
                        if (!node2.value) {
                            errorMessage = localize2("uriEmpty", "URI expected.");
                        } else {
                            var match = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/.exec(node2.value);
                            if (!match) {
                                errorMessage = localize2("uriMissing", "URI is expected.");
                            } else if (!match[2] && schema5.format === "uri") {
                                errorMessage = localize2("uriSchemeMissing", "URI with a scheme is expected.");
                            }
                        }
                        if (errorMessage) {
                            validationResult2.problems.push({
                                location: {
                                    offset: node2.offset,
                                    length: node2.length
                                },
                                message: schema5.patternErrorMessage || schema5.errorMessage || localize2("uriFormatWarning", "String is not a URI: {0}", errorMessage)
                            });
                        }
                    }
                    break;
                case "color-hex":
                case "date-time":
                case "date":
                case "time":
                case "email":
                    var format5 = formats[schema5.format];
                    if (!node2.value || !format5.pattern.exec(node2.value)) {
                        validationResult2.problems.push({
                            location: {
                                offset: node2.offset,
                                length: node2.length
                            },
                            message: schema5.patternErrorMessage || schema5.errorMessage || format5.errorMessage
                        });
                    }
                default:
            }
        }
    }
    function _validateArrayNode(node2, schema5, validationResult2, matchingSchemas2) {
        if (Array.isArray(schema5.items)) {
            var subSchemas = schema5.items;
            for(var index = 0; index < subSchemas.length; index++){
                var subSchemaRef = subSchemas[index];
                var subSchema = asSchema(subSchemaRef);
                var itemValidationResult = new ValidationResult();
                var item = node2.items[index];
                if (item) {
                    validate(item, subSchema, itemValidationResult, matchingSchemas2);
                    validationResult2.mergePropertyMatch(itemValidationResult);
                } else if (node2.items.length >= subSchemas.length) {
                    validationResult2.propertiesValueMatches++;
                }
            }
            if (node2.items.length > subSchemas.length) {
                if (typeof schema5.additionalItems === "object") {
                    for(var i = subSchemas.length; i < node2.items.length; i++){
                        var itemValidationResult = new ValidationResult();
                        validate(node2.items[i], schema5.additionalItems, itemValidationResult, matchingSchemas2);
                        validationResult2.mergePropertyMatch(itemValidationResult);
                    }
                } else if (schema5.additionalItems === false) {
                    validationResult2.problems.push({
                        location: {
                            offset: node2.offset,
                            length: node2.length
                        },
                        message: localize2("additionalItemsWarning", "Array has too many items according to schema. Expected {0} or fewer.", subSchemas.length)
                    });
                }
            }
        } else {
            var itemSchema = asSchema(schema5.items);
            if (itemSchema) {
                for(var _i = 0, _a = node2.items; _i < _a.length; _i++){
                    var item = _a[_i];
                    var itemValidationResult = new ValidationResult();
                    validate(item, itemSchema, itemValidationResult, matchingSchemas2);
                    validationResult2.mergePropertyMatch(itemValidationResult);
                }
            }
        }
        var containsSchema = asSchema(schema5.contains);
        if (containsSchema) {
            var doesContain = node2.items.some(function(item2) {
                var itemValidationResult2 = new ValidationResult();
                validate(item2, containsSchema, itemValidationResult2, NoOpSchemaCollector.instance);
                return !itemValidationResult2.hasProblems();
            });
            if (!doesContain) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    message: schema5.errorMessage || localize2("requiredItemMissingWarning", "Array does not contain required item.")
                });
            }
        }
        if (isNumber(schema5.minItems) && node2.items.length < schema5.minItems) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                message: localize2("minItemsWarning", "Array has too few items. Expected {0} or more.", schema5.minItems)
            });
        }
        if (isNumber(schema5.maxItems) && node2.items.length > schema5.maxItems) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                message: localize2("maxItemsWarning", "Array has too many items. Expected {0} or fewer.", schema5.maxItems)
            });
        }
        if (schema5.uniqueItems === true) {
            var values_1 = getNodeValue3(node2);
            var duplicates = values_1.some(function(value1, index2) {
                return index2 !== values_1.lastIndexOf(value1);
            });
            if (duplicates) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    message: localize2("uniqueItemsWarning", "Array has duplicate items.")
                });
            }
        }
    }
    function _validateObjectNode(node2, schema5, validationResult2, matchingSchemas2) {
        var seenKeys = /* @__PURE__ */ Object.create(null);
        var unprocessedProperties = [];
        for(var _i = 0, _a = node2.properties; _i < _a.length; _i++){
            var propertyNode = _a[_i];
            var key = propertyNode.keyNode.value;
            seenKeys[key] = propertyNode.valueNode;
            unprocessedProperties.push(key);
        }
        if (Array.isArray(schema5.required)) {
            for(var _b = 0, _c = schema5.required; _b < _c.length; _b++){
                var propertyName = _c[_b];
                if (!seenKeys[propertyName]) {
                    var keyNode = node2.parent && node2.parent.type === "property" && node2.parent.keyNode;
                    var location = keyNode ? {
                        offset: keyNode.offset,
                        length: keyNode.length
                    } : {
                        offset: node2.offset,
                        length: 1
                    };
                    validationResult2.problems.push({
                        location,
                        message: localize2("MissingRequiredPropWarning", 'Missing property "{0}".', propertyName)
                    });
                }
            }
        }
        var propertyProcessed = function(prop2) {
            var index = unprocessedProperties.indexOf(prop2);
            while(index >= 0){
                unprocessedProperties.splice(index, 1);
                index = unprocessedProperties.indexOf(prop2);
            }
        };
        if (schema5.properties) {
            for(var _d = 0, _e = Object.keys(schema5.properties); _d < _e.length; _d++){
                var propertyName = _e[_d];
                propertyProcessed(propertyName);
                var propertySchema = schema5.properties[propertyName];
                var child = seenKeys[propertyName];
                if (child) {
                    if (isBoolean(propertySchema)) {
                        if (!propertySchema) {
                            var propertyNode = child.parent;
                            validationResult2.problems.push({
                                location: {
                                    offset: propertyNode.keyNode.offset,
                                    length: propertyNode.keyNode.length
                                },
                                message: schema5.errorMessage || localize2("DisallowedExtraPropWarning", "Property {0} is not allowed.", propertyName)
                            });
                        } else {
                            validationResult2.propertiesMatches++;
                            validationResult2.propertiesValueMatches++;
                        }
                    } else {
                        var propertyValidationResult = new ValidationResult();
                        validate(child, propertySchema, propertyValidationResult, matchingSchemas2);
                        validationResult2.mergePropertyMatch(propertyValidationResult);
                    }
                }
            }
        }
        if (schema5.patternProperties) {
            for(var _f = 0, _g = Object.keys(schema5.patternProperties); _f < _g.length; _f++){
                var propertyPattern = _g[_f];
                var regex = extendedRegExp(propertyPattern);
                for(var _h = 0, _j = unprocessedProperties.slice(0); _h < _j.length; _h++){
                    var propertyName = _j[_h];
                    if (regex.test(propertyName)) {
                        propertyProcessed(propertyName);
                        var child = seenKeys[propertyName];
                        if (child) {
                            var propertySchema = schema5.patternProperties[propertyPattern];
                            if (isBoolean(propertySchema)) {
                                if (!propertySchema) {
                                    var propertyNode = child.parent;
                                    validationResult2.problems.push({
                                        location: {
                                            offset: propertyNode.keyNode.offset,
                                            length: propertyNode.keyNode.length
                                        },
                                        message: schema5.errorMessage || localize2("DisallowedExtraPropWarning", "Property {0} is not allowed.", propertyName)
                                    });
                                } else {
                                    validationResult2.propertiesMatches++;
                                    validationResult2.propertiesValueMatches++;
                                }
                            } else {
                                var propertyValidationResult = new ValidationResult();
                                validate(child, propertySchema, propertyValidationResult, matchingSchemas2);
                                validationResult2.mergePropertyMatch(propertyValidationResult);
                            }
                        }
                    }
                }
            }
        }
        if (typeof schema5.additionalProperties === "object") {
            for(var _k = 0, unprocessedProperties_1 = unprocessedProperties; _k < unprocessedProperties_1.length; _k++){
                var propertyName = unprocessedProperties_1[_k];
                var child = seenKeys[propertyName];
                if (child) {
                    var propertyValidationResult = new ValidationResult();
                    validate(child, schema5.additionalProperties, propertyValidationResult, matchingSchemas2);
                    validationResult2.mergePropertyMatch(propertyValidationResult);
                }
            }
        } else if (schema5.additionalProperties === false) {
            if (unprocessedProperties.length > 0) {
                for(var _l = 0, unprocessedProperties_2 = unprocessedProperties; _l < unprocessedProperties_2.length; _l++){
                    var propertyName = unprocessedProperties_2[_l];
                    var child = seenKeys[propertyName];
                    if (child) {
                        var propertyNode = child.parent;
                        validationResult2.problems.push({
                            location: {
                                offset: propertyNode.keyNode.offset,
                                length: propertyNode.keyNode.length
                            },
                            message: schema5.errorMessage || localize2("DisallowedExtraPropWarning", "Property {0} is not allowed.", propertyName)
                        });
                    }
                }
            }
        }
        if (isNumber(schema5.maxProperties)) {
            if (node2.properties.length > schema5.maxProperties) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    message: localize2("MaxPropWarning", "Object has more properties than limit of {0}.", schema5.maxProperties)
                });
            }
        }
        if (isNumber(schema5.minProperties)) {
            if (node2.properties.length < schema5.minProperties) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    message: localize2("MinPropWarning", "Object has fewer properties than the required number of {0}", schema5.minProperties)
                });
            }
        }
        if (schema5.dependencies) {
            for(var _m = 0, _o = Object.keys(schema5.dependencies); _m < _o.length; _m++){
                var key = _o[_m];
                var prop = seenKeys[key];
                if (prop) {
                    var propertyDep = schema5.dependencies[key];
                    if (Array.isArray(propertyDep)) {
                        for(var _p = 0, propertyDep_1 = propertyDep; _p < propertyDep_1.length; _p++){
                            var requiredProp = propertyDep_1[_p];
                            if (!seenKeys[requiredProp]) {
                                validationResult2.problems.push({
                                    location: {
                                        offset: node2.offset,
                                        length: node2.length
                                    },
                                    message: localize2("RequiredDependentPropWarning", "Object is missing property {0} required by property {1}.", requiredProp, key)
                                });
                            } else {
                                validationResult2.propertiesValueMatches++;
                            }
                        }
                    } else {
                        var propertySchema = asSchema(propertyDep);
                        if (propertySchema) {
                            var propertyValidationResult = new ValidationResult();
                            validate(node2, propertySchema, propertyValidationResult, matchingSchemas2);
                            validationResult2.mergePropertyMatch(propertyValidationResult);
                        }
                    }
                }
            }
        }
        var propertyNames = asSchema(schema5.propertyNames);
        if (propertyNames) {
            for(var _q = 0, _r = node2.properties; _q < _r.length; _q++){
                var f2 = _r[_q];
                var key = f2.keyNode;
                if (key) {
                    validate(key, propertyNames, validationResult2, NoOpSchemaCollector.instance);
                }
            }
        }
    }
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/utils/glob.js
function createRegex(glob, opts) {
    if (typeof glob !== "string") {
        throw new TypeError("Expected a string");
    }
    var str = String(glob);
    var reStr = "";
    var extended = opts ? !!opts.extended : false;
    var globstar = opts ? !!opts.globstar : false;
    var inGroup = false;
    var flags = opts && typeof opts.flags === "string" ? opts.flags : "";
    var c;
    for(var i = 0, len = str.length; i < len; i++){
        c = str[i];
        switch(c){
            case "/":
            case "$":
            case "^":
            case "+":
            case ".":
            case "(":
            case ")":
            case "=":
            case "!":
            case "|":
                reStr += "\\" + c;
                break;
            case "?":
                if (extended) {
                    reStr += ".";
                    break;
                }
            case "[":
            case "]":
                if (extended) {
                    reStr += c;
                    break;
                }
            case "{":
                if (extended) {
                    inGroup = true;
                    reStr += "(";
                    break;
                }
            case "}":
                if (extended) {
                    inGroup = false;
                    reStr += ")";
                    break;
                }
            case ",":
                if (inGroup) {
                    reStr += "|";
                    break;
                }
                reStr += "\\" + c;
                break;
            case "*":
                var prevChar = str[i - 1];
                var starCount = 1;
                while(str[i + 1] === "*"){
                    starCount++;
                    i++;
                }
                var nextChar = str[i + 1];
                if (!globstar) {
                    reStr += ".*";
                } else {
                    var isGlobstar = starCount > 1 && (prevChar === "/" || prevChar === void 0 || prevChar === "{" || prevChar === ",") && (nextChar === "/" || nextChar === void 0 || nextChar === "," || nextChar === "}");
                    if (isGlobstar) {
                        if (nextChar === "/") {
                            i++;
                        } else if (prevChar === "/" && reStr.endsWith("\\/")) {
                            reStr = reStr.substr(0, reStr.length - 2);
                        }
                        reStr += "((?:[^/]*(?:/|$))*)";
                    } else {
                        reStr += "([^/]*)";
                    }
                }
                break;
            default:
                reStr += c;
        }
    }
    if (!flags || !~flags.indexOf("g")) {
        reStr = "^" + reStr + "$";
    }
    return new RegExp(reStr, flags);
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/services/jsonSchemaService.js
var localize3 = loadMessageBundle();
var BANG = "!";
var PATH_SEP = "/";
var FilePatternAssociation = /** @class */ function() {
    function FilePatternAssociation3(pattern, uris) {
        this.globWrappers = [];
        try {
            for(var _i = 0, pattern_1 = pattern; _i < pattern_1.length; _i++){
                var patternString = pattern_1[_i];
                var include = patternString[0] !== BANG;
                if (!include) {
                    patternString = patternString.substring(1);
                }
                if (patternString.length > 0) {
                    if (patternString[0] === PATH_SEP) {
                        patternString = patternString.substring(1);
                    }
                    this.globWrappers.push({
                        regexp: createRegex("**/" + patternString, {
                            extended: true,
                            globstar: true
                        }),
                        include
                    });
                }
            }
            ;
            this.uris = uris;
        } catch (e) {
            this.globWrappers.length = 0;
            this.uris = [];
        }
    }
    FilePatternAssociation3.prototype.matchesPattern = function(fileName) {
        var match = false;
        for(var _i = 0, _a = this.globWrappers; _i < _a.length; _i++){
            var _b = _a[_i], regexp = _b.regexp, include = _b.include;
            if (regexp.test(fileName)) {
                match = include;
            }
        }
        return match;
    };
    FilePatternAssociation3.prototype.getURIs = function() {
        return this.uris;
    };
    return FilePatternAssociation3;
}();
var SchemaHandle = /** @class */ function() {
    function SchemaHandle2(service, url, unresolvedSchemaContent) {
        this.service = service;
        this.url = url;
        this.dependencies = {};
        if (unresolvedSchemaContent) {
            this.unresolvedSchema = this.service.promise.resolve(new UnresolvedSchema(unresolvedSchemaContent));
        }
    }
    SchemaHandle2.prototype.getUnresolvedSchema = function() {
        if (!this.unresolvedSchema) {
            this.unresolvedSchema = this.service.loadSchema(this.url);
        }
        return this.unresolvedSchema;
    };
    SchemaHandle2.prototype.getResolvedSchema = function() {
        var _this = this;
        if (!this.resolvedSchema) {
            this.resolvedSchema = this.getUnresolvedSchema().then(function(unresolved) {
                return _this.service.resolveSchemaContent(unresolved, _this.url, _this.dependencies);
            });
        }
        return this.resolvedSchema;
    };
    SchemaHandle2.prototype.clearSchema = function() {
        this.resolvedSchema = void 0;
        this.unresolvedSchema = void 0;
        this.dependencies = {};
    };
    return SchemaHandle2;
}();
var UnresolvedSchema = /** @class */ /* @__PURE__ */ function() {
    function UnresolvedSchema2(schema4, errors) {
        if (errors === void 0) {
            errors = [];
        }
        this.schema = schema4;
        this.errors = errors;
    }
    return UnresolvedSchema2;
}();
var ResolvedSchema = /** @class */ function() {
    function ResolvedSchema2(schema4, errors) {
        if (errors === void 0) {
            errors = [];
        }
        this.schema = schema4;
        this.errors = errors;
    }
    ResolvedSchema2.prototype.getSection = function(path5) {
        var schemaRef = this.getSectionRecursive(path5, this.schema);
        if (schemaRef) {
            return asSchema(schemaRef);
        }
        return void 0;
    };
    ResolvedSchema2.prototype.getSectionRecursive = function(path5, schema4) {
        if (!schema4 || typeof schema4 === "boolean" || path5.length === 0) {
            return schema4;
        }
        var next = path5.shift();
        if (schema4.properties && typeof schema4.properties[next]) {
            return this.getSectionRecursive(path5, schema4.properties[next]);
        } else if (schema4.patternProperties) {
            for(var _i = 0, _a = Object.keys(schema4.patternProperties); _i < _a.length; _i++){
                var pattern = _a[_i];
                var regex = extendedRegExp(pattern);
                if (regex.test(next)) {
                    return this.getSectionRecursive(path5, schema4.patternProperties[pattern]);
                }
            }
        } else if (typeof schema4.additionalProperties === "object") {
            return this.getSectionRecursive(path5, schema4.additionalProperties);
        } else if (next.match("[0-9]+")) {
            if (Array.isArray(schema4.items)) {
                var index = parseInt(next, 10);
                if (!isNaN(index) && schema4.items[index]) {
                    return this.getSectionRecursive(path5, schema4.items[index]);
                }
            } else if (schema4.items) {
                return this.getSectionRecursive(path5, schema4.items);
            }
        }
        return void 0;
    };
    return ResolvedSchema2;
}();
var JSONSchemaService = /** @class */ function() {
    function JSONSchemaService2(requestService, contextService, promiseConstructor) {
        this.contextService = contextService;
        this.requestService = requestService;
        this.promiseConstructor = promiseConstructor || Promise;
        this.callOnDispose = [];
        this.contributionSchemas = {};
        this.contributionAssociations = [];
        this.schemasById = {};
        this.filePatternAssociations = [];
        this.registeredSchemasIds = {};
    }
    JSONSchemaService2.prototype.getRegisteredSchemaIds = function(filter) {
        return Object.keys(this.registeredSchemasIds).filter(function(id) {
            var scheme = yaml_service_URI.parse(id).scheme;
            return scheme !== "schemaservice" && (!filter || filter(scheme));
        });
    };
    Object.defineProperty(JSONSchemaService2.prototype, "promise", {
        get: function() {
            return this.promiseConstructor;
        },
        enumerable: false,
        configurable: true
    });
    JSONSchemaService2.prototype.dispose = function() {
        while(this.callOnDispose.length > 0){
            this.callOnDispose.pop()();
        }
    };
    JSONSchemaService2.prototype.onResourceChange = function(uri) {
        var _this = this;
        this.cachedSchemaForResource = void 0;
        var hasChanges = false;
        uri = normalizeId(uri);
        var toWalk = [
            uri
        ];
        var all = Object.keys(this.schemasById).map(function(key) {
            return _this.schemasById[key];
        });
        while(toWalk.length){
            var curr = toWalk.pop();
            for(var i = 0; i < all.length; i++){
                var handle = all[i];
                if (handle && (handle.url === curr || handle.dependencies[curr])) {
                    if (handle.url !== curr) {
                        toWalk.push(handle.url);
                    }
                    handle.clearSchema();
                    all[i] = void 0;
                    hasChanges = true;
                }
            }
        }
        return hasChanges;
    };
    JSONSchemaService2.prototype.setSchemaContributions = function(schemaContributions2) {
        if (schemaContributions2.schemas) {
            var schemas2 = schemaContributions2.schemas;
            for(var id in schemas2){
                var normalizedId = normalizeId(id);
                this.contributionSchemas[normalizedId] = this.addSchemaHandle(normalizedId, schemas2[id]);
            }
        }
        if (Array.isArray(schemaContributions2.schemaAssociations)) {
            var schemaAssociations = schemaContributions2.schemaAssociations;
            for(var _i = 0, schemaAssociations_1 = schemaAssociations; _i < schemaAssociations_1.length; _i++){
                var schemaAssociation = schemaAssociations_1[_i];
                var uris = schemaAssociation.uris.map(normalizeId);
                var association = this.addFilePatternAssociation(schemaAssociation.pattern, uris);
                this.contributionAssociations.push(association);
            }
        }
    };
    JSONSchemaService2.prototype.addSchemaHandle = function(id, unresolvedSchemaContent) {
        var schemaHandle = new SchemaHandle(this, id, unresolvedSchemaContent);
        this.schemasById[id] = schemaHandle;
        return schemaHandle;
    };
    JSONSchemaService2.prototype.getOrAddSchemaHandle = function(id, unresolvedSchemaContent) {
        return this.schemasById[id] || this.addSchemaHandle(id, unresolvedSchemaContent);
    };
    JSONSchemaService2.prototype.addFilePatternAssociation = function(pattern, uris) {
        var fpa = new FilePatternAssociation(pattern, uris);
        this.filePatternAssociations.push(fpa);
        return fpa;
    };
    JSONSchemaService2.prototype.registerExternalSchema = function(uri, filePatterns, unresolvedSchemaContent) {
        var id = normalizeId(uri);
        this.registeredSchemasIds[id] = true;
        this.cachedSchemaForResource = void 0;
        if (filePatterns) {
            this.addFilePatternAssociation(filePatterns, [
                uri
            ]);
        }
        return unresolvedSchemaContent ? this.addSchemaHandle(id, unresolvedSchemaContent) : this.getOrAddSchemaHandle(id);
    };
    JSONSchemaService2.prototype.clearExternalSchemas = function() {
        this.schemasById = {};
        this.filePatternAssociations = [];
        this.registeredSchemasIds = {};
        this.cachedSchemaForResource = void 0;
        for(var id in this.contributionSchemas){
            this.schemasById[id] = this.contributionSchemas[id];
            this.registeredSchemasIds[id] = true;
        }
        for(var _i = 0, _a = this.contributionAssociations; _i < _a.length; _i++){
            var contributionAssociation = _a[_i];
            this.filePatternAssociations.push(contributionAssociation);
        }
    };
    JSONSchemaService2.prototype.getResolvedSchema = function(schemaId) {
        var id = normalizeId(schemaId);
        var schemaHandle = this.schemasById[id];
        if (schemaHandle) {
            return schemaHandle.getResolvedSchema();
        }
        return this.promise.resolve(void 0);
    };
    JSONSchemaService2.prototype.loadSchema = function(url) {
        if (!this.requestService) {
            var errorMessage = localize3("json.schema.norequestservice", "Unable to load schema from '{0}'. No schema request service available", toDisplayString(url));
            return this.promise.resolve(new UnresolvedSchema({}, [
                errorMessage
            ]));
        }
        return this.requestService(url).then(function(content) {
            if (!content) {
                var errorMessage2 = localize3("json.schema.nocontent", "Unable to load schema from '{0}': No content.", toDisplayString(url));
                return new UnresolvedSchema({}, [
                    errorMessage2
                ]);
            }
            var schemaContent = {};
            var jsonErrors = [];
            schemaContent = parse2(content, jsonErrors);
            var errors = jsonErrors.length ? [
                localize3("json.schema.invalidFormat", "Unable to parse content from '{0}': Parse error at offset {1}.", toDisplayString(url), jsonErrors[0].offset)
            ] : [];
            return new UnresolvedSchema(schemaContent, errors);
        }, function(error) {
            var errorMessage2 = error.toString();
            var errorSplit = error.toString().split("Error: ");
            if (errorSplit.length > 1) {
                errorMessage2 = errorSplit[1];
            }
            if (endsWith(errorMessage2, ".")) {
                errorMessage2 = errorMessage2.substr(0, errorMessage2.length - 1);
            }
            return new UnresolvedSchema({}, [
                localize3("json.schema.nocontent", "Unable to load schema from '{0}': {1}.", toDisplayString(url), errorMessage2)
            ]);
        });
    };
    JSONSchemaService2.prototype.resolveSchemaContent = function(schemaToResolve, schemaURL, dependencies) {
        var _this = this;
        var resolveErrors = schemaToResolve.errors.slice(0);
        var schema4 = schemaToResolve.schema;
        if (schema4.$schema) {
            var id = normalizeId(schema4.$schema);
            if (id === "http://json-schema.org/draft-03/schema") {
                return this.promise.resolve(new ResolvedSchema({}, [
                    localize3("json.schema.draft03.notsupported", "Draft-03 schemas are not supported.")
                ]));
            } else if (id === "https://json-schema.org/draft/2019-09/schema") {
                resolveErrors.push(localize3("json.schema.draft201909.notsupported", "Draft 2019-09 schemas are not yet fully supported."));
            }
        }
        var contextService = this.contextService;
        var findSection = function(schema5, path5) {
            if (!path5) {
                return schema5;
            }
            var current = schema5;
            if (path5[0] === "/") {
                path5 = path5.substr(1);
            }
            path5.split("/").some(function(part) {
                part = part.replace(/~1/g, "/").replace(/~0/g, "~");
                current = current[part];
                return !current;
            });
            return current;
        };
        var merge = function(target, sourceRoot, sourceURI, refSegment) {
            var path5 = refSegment ? decodeURIComponent(refSegment) : void 0;
            var section = findSection(sourceRoot, path5);
            if (section) {
                for(var key in section){
                    if (section.hasOwnProperty(key) && !target.hasOwnProperty(key)) {
                        target[key] = section[key];
                    }
                }
            } else {
                resolveErrors.push(localize3("json.schema.invalidref", "$ref '{0}' in '{1}' can not be resolved.", path5, sourceURI));
            }
        };
        var resolveExternalLink = function(node, uri, refSegment, parentSchemaURL, parentSchemaDependencies) {
            if (contextService && !/^[A-Za-z][A-Za-z0-9+\-.+]*:\/\/.*/.test(uri)) {
                uri = contextService.resolveRelativePath(uri, parentSchemaURL);
            }
            uri = normalizeId(uri);
            var referencedHandle = _this.getOrAddSchemaHandle(uri);
            return referencedHandle.getUnresolvedSchema().then(function(unresolvedSchema) {
                parentSchemaDependencies[uri] = true;
                if (unresolvedSchema.errors.length) {
                    var loc = refSegment ? uri + "#" + refSegment : uri;
                    resolveErrors.push(localize3("json.schema.problemloadingref", "Problems loading reference '{0}': {1}", loc, unresolvedSchema.errors[0]));
                }
                merge(node, unresolvedSchema.schema, uri, refSegment);
                return resolveRefs(node, unresolvedSchema.schema, uri, referencedHandle.dependencies);
            });
        };
        var resolveRefs = function(node, parentSchema, parentSchemaURL, parentSchemaDependencies) {
            if (!node || typeof node !== "object") {
                return Promise.resolve(null);
            }
            var toWalk = [
                node
            ];
            var seen = [];
            var openPromises = [];
            var collectEntries = function() {
                var entries = [];
                for(var _i = 0; _i < arguments.length; _i++){
                    entries[_i] = arguments[_i];
                }
                for(var _a = 0, entries_1 = entries; _a < entries_1.length; _a++){
                    var entry = entries_1[_a];
                    if (typeof entry === "object") {
                        toWalk.push(entry);
                    }
                }
            };
            var collectMapEntries = function() {
                var maps = [];
                for(var _i = 0; _i < arguments.length; _i++){
                    maps[_i] = arguments[_i];
                }
                for(var _a = 0, maps_1 = maps; _a < maps_1.length; _a++){
                    var map2 = maps_1[_a];
                    if (typeof map2 === "object") {
                        for(var k in map2){
                            var key = k;
                            var entry = map2[key];
                            if (typeof entry === "object") {
                                toWalk.push(entry);
                            }
                        }
                    }
                }
            };
            var collectArrayEntries = function() {
                var arrays = [];
                for(var _i = 0; _i < arguments.length; _i++){
                    arrays[_i] = arguments[_i];
                }
                for(var _a = 0, arrays_1 = arrays; _a < arrays_1.length; _a++){
                    var array = arrays_1[_a];
                    if (Array.isArray(array)) {
                        for(var _b = 0, array_1 = array; _b < array_1.length; _b++){
                            var entry = array_1[_b];
                            if (typeof entry === "object") {
                                toWalk.push(entry);
                            }
                        }
                    }
                }
            };
            var handleRef = function(next2) {
                var seenRefs = [];
                while(next2.$ref){
                    var ref = next2.$ref;
                    var segments = ref.split("#", 2);
                    delete next2.$ref;
                    if (segments[0].length > 0) {
                        openPromises.push(resolveExternalLink(next2, segments[0], segments[1], parentSchemaURL, parentSchemaDependencies));
                        return;
                    } else {
                        if (seenRefs.indexOf(ref) === -1) {
                            merge(next2, parentSchema, parentSchemaURL, segments[1]);
                            seenRefs.push(ref);
                        }
                    }
                }
                collectEntries(next2.items, next2.additionalItems, next2.additionalProperties, next2.not, next2.contains, next2.propertyNames, next2.if, next2.then, next2.else);
                collectMapEntries(next2.definitions, next2.properties, next2.patternProperties, next2.dependencies);
                collectArrayEntries(next2.anyOf, next2.allOf, next2.oneOf, next2.items);
            };
            while(toWalk.length){
                var next = toWalk.pop();
                if (seen.indexOf(next) >= 0) {
                    continue;
                }
                seen.push(next);
                handleRef(next);
            }
            return _this.promise.all(openPromises);
        };
        return resolveRefs(schema4, schema4, schemaURL, dependencies).then(function(_2) {
            return new ResolvedSchema(schema4, resolveErrors);
        });
    };
    JSONSchemaService2.prototype.getSchemaForResource = function(resource, document2) {
        if (document2 && document2.root && document2.root.type === "object") {
            var schemaProperties = document2.root.properties.filter(function(p) {
                return p.keyNode.value === "$schema" && p.valueNode && p.valueNode.type === "string";
            });
            if (schemaProperties.length > 0) {
                var valueNode = schemaProperties[0].valueNode;
                if (valueNode && valueNode.type === "string") {
                    var schemeId = getNodeValue3(valueNode);
                    if (schemeId && startsWith(schemeId, ".") && this.contextService) {
                        schemeId = this.contextService.resolveRelativePath(schemeId, resource);
                    }
                    if (schemeId) {
                        var id = normalizeId(schemeId);
                        return this.getOrAddSchemaHandle(id).getResolvedSchema();
                    }
                }
            }
        }
        if (this.cachedSchemaForResource && this.cachedSchemaForResource.resource === resource) {
            return this.cachedSchemaForResource.resolvedSchema;
        }
        var seen = /* @__PURE__ */ Object.create(null);
        var schemas2 = [];
        var normalizedResource = normalizeResourceForMatching(resource);
        for(var _i = 0, _a = this.filePatternAssociations; _i < _a.length; _i++){
            var entry = _a[_i];
            if (entry.matchesPattern(normalizedResource)) {
                for(var _b = 0, _c = entry.getURIs(); _b < _c.length; _b++){
                    var schemaId = _c[_b];
                    if (!seen[schemaId]) {
                        schemas2.push(schemaId);
                        seen[schemaId] = true;
                    }
                }
            }
        }
        var resolvedSchema = schemas2.length > 0 ? this.createCombinedSchema(resource, schemas2).getResolvedSchema() : this.promise.resolve(void 0);
        this.cachedSchemaForResource = {
            resource,
            resolvedSchema
        };
        return resolvedSchema;
    };
    JSONSchemaService2.prototype.createCombinedSchema = function(resource, schemaIds) {
        if (schemaIds.length === 1) {
            return this.getOrAddSchemaHandle(schemaIds[0]);
        } else {
            var combinedSchemaId = "schemaservice://combinedSchema/" + encodeURIComponent(resource);
            var combinedSchema = {
                allOf: schemaIds.map(function(schemaId) {
                    return {
                        $ref: schemaId
                    };
                })
            };
            return this.addSchemaHandle(combinedSchemaId, combinedSchema);
        }
    };
    JSONSchemaService2.prototype.getMatchingSchemas = function(document2, jsonDocument, schema4) {
        if (schema4) {
            var id = schema4.id || "schemaservice://untitled/matchingSchemas/" + idCounter++;
            return this.resolveSchemaContent(new UnresolvedSchema(schema4), id, {}).then(function(resolvedSchema) {
                return jsonDocument.getMatchingSchemas(resolvedSchema.schema).filter(function(s) {
                    return !s.inverted;
                });
            });
        }
        return this.getSchemaForResource(document2.uri, jsonDocument).then(function(schema5) {
            if (schema5) {
                return jsonDocument.getMatchingSchemas(schema5.schema).filter(function(s) {
                    return !s.inverted;
                });
            }
            return [];
        });
    };
    return JSONSchemaService2;
}();
var idCounter = 0;
function normalizeId(id) {
    try {
        return yaml_service_URI.parse(id).toString();
    } catch (e) {
        return id;
    }
}
function normalizeResourceForMatching(resource) {
    try {
        return yaml_service_URI.parse(resource).with({
            fragment: null,
            query: null
        }).toString();
    } catch (e) {
        return resource;
    }
}
function toDisplayString(url) {
    try {
        var uri = yaml_service_URI.parse(url);
        if (uri.scheme === "file") {
            return uri.fsPath;
        }
    } catch (e) {}
    return url;
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/utils/strings.js
function convertSimple2RegExpPattern(pattern) {
    return pattern.replace(/[-\\{}+?|^$.,[\]()#\s]/g, "\\$&").replace(/[*]/g, ".*");
}
function getIndentation(lineContent, position) {
    if (lineContent.length < position) {
        return 0;
    }
    for(let i = 0; i < position; i++){
        const char = lineContent.charCodeAt(i);
        if (char !== 32 && char !== 9) {
            return i;
        }
    }
    return position;
}
function safeCreateUnicodeRegExp(pattern) {
    try {
        return new RegExp(pattern, "u");
    } catch (ignore) {
        return new RegExp(pattern);
    }
}
function getFirstNonWhitespaceCharacterAfterOffset(str, offset) {
    offset++;
    for(let i = offset; i < str.length; i++){
        const char = str.charAt(i);
        if (char === " " || char === "	") {
            offset++;
        } else {
            return offset;
        }
    }
    return offset;
}
// ../../node_modules/yaml/browser/dist/nodes/Node.js
var ALIAS = Symbol.for("yaml.alias");
var DOC = Symbol.for("yaml.document");
var MAP = Symbol.for("yaml.map");
var PAIR = Symbol.for("yaml.pair");
var SCALAR = Symbol.for("yaml.scalar");
var SEQ = Symbol.for("yaml.seq");
var NODE_TYPE = Symbol.for("yaml.node.type");
var isAlias = (node)=>!!node && typeof node === "object" && node[NODE_TYPE] === ALIAS;
var isDocument = (node)=>!!node && typeof node === "object" && node[NODE_TYPE] === DOC;
var isMap = (node)=>!!node && typeof node === "object" && node[NODE_TYPE] === MAP;
var isPair = (node)=>!!node && typeof node === "object" && node[NODE_TYPE] === PAIR;
var isScalar = (node)=>!!node && typeof node === "object" && node[NODE_TYPE] === SCALAR;
var isSeq = (node)=>!!node && typeof node === "object" && node[NODE_TYPE] === SEQ;
function isCollection(node) {
    if (node && typeof node === "object") switch(node[NODE_TYPE]){
        case MAP:
        case SEQ:
            return true;
    }
    return false;
}
function isNode(node) {
    if (node && typeof node === "object") switch(node[NODE_TYPE]){
        case ALIAS:
        case MAP:
        case SCALAR:
        case SEQ:
            return true;
    }
    return false;
}
var hasAnchor = (node)=>(isScalar(node) || isCollection(node)) && !!node.anchor;
var NodeBase = class {
    /** Create a copy of this node.  */ clone() {
        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
        if (this.range) copy.range = this.range.slice();
        return copy;
    }
    constructor(type){
        Object.defineProperty(this, NODE_TYPE, {
            value: type
        });
    }
};
// ../../node_modules/yaml/browser/dist/visit.js
var BREAK = Symbol("break visit");
var SKIP = Symbol("skip children");
var REMOVE = Symbol("remove node");
function visit2(node, visitor) {
    const visitor_ = initVisitor(visitor);
    if (isDocument(node)) {
        const cd = visit_(null, node.contents, visitor_, Object.freeze([
            node
        ]));
        if (cd === REMOVE) node.contents = null;
    } else visit_(null, node, visitor_, Object.freeze([]));
}
visit2.BREAK = BREAK;
visit2.SKIP = SKIP;
visit2.REMOVE = REMOVE;
function visit_(key, node, visitor, path5) {
    const ctrl = callVisitor(key, node, visitor, path5);
    if (isNode(ctrl) || isPair(ctrl)) {
        replaceNode(key, path5, ctrl);
        return visit_(key, ctrl, visitor, path5);
    }
    if (typeof ctrl !== "symbol") {
        if (isCollection(node)) {
            path5 = Object.freeze(path5.concat(node));
            for(let i = 0; i < node.items.length; ++i){
                const ci = visit_(i, node.items[i], visitor, path5);
                if (typeof ci === "number") i = ci - 1;
                else if (ci === BREAK) return BREAK;
                else if (ci === REMOVE) {
                    node.items.splice(i, 1);
                    i -= 1;
                }
            }
        } else if (isPair(node)) {
            path5 = Object.freeze(path5.concat(node));
            const ck = visit_("key", node.key, visitor, path5);
            if (ck === BREAK) return BREAK;
            else if (ck === REMOVE) node.key = null;
            const cv = visit_("value", node.value, visitor, path5);
            if (cv === BREAK) return BREAK;
            else if (cv === REMOVE) node.value = null;
        }
    }
    return ctrl;
}
async function visitAsync(node, visitor) {
    const visitor_ = initVisitor(visitor);
    if (isDocument(node)) {
        const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([
            node
        ]));
        if (cd === REMOVE) node.contents = null;
    } else await visitAsync_(null, node, visitor_, Object.freeze([]));
}
visitAsync.BREAK = BREAK;
visitAsync.SKIP = SKIP;
visitAsync.REMOVE = REMOVE;
async function visitAsync_(key, node, visitor, path5) {
    const ctrl = await callVisitor(key, node, visitor, path5);
    if (isNode(ctrl) || isPair(ctrl)) {
        replaceNode(key, path5, ctrl);
        return visitAsync_(key, ctrl, visitor, path5);
    }
    if (typeof ctrl !== "symbol") {
        if (isCollection(node)) {
            path5 = Object.freeze(path5.concat(node));
            for(let i = 0; i < node.items.length; ++i){
                const ci = await visitAsync_(i, node.items[i], visitor, path5);
                if (typeof ci === "number") i = ci - 1;
                else if (ci === BREAK) return BREAK;
                else if (ci === REMOVE) {
                    node.items.splice(i, 1);
                    i -= 1;
                }
            }
        } else if (isPair(node)) {
            path5 = Object.freeze(path5.concat(node));
            const ck = await visitAsync_("key", node.key, visitor, path5);
            if (ck === BREAK) return BREAK;
            else if (ck === REMOVE) node.key = null;
            const cv = await visitAsync_("value", node.value, visitor, path5);
            if (cv === BREAK) return BREAK;
            else if (cv === REMOVE) node.value = null;
        }
    }
    return ctrl;
}
function initVisitor(visitor) {
    if (typeof visitor === "object" && (visitor.Collection || visitor.Node || visitor.Value)) {
        return Object.assign({
            Alias: visitor.Node,
            Map: visitor.Node,
            Scalar: visitor.Node,
            Seq: visitor.Node
        }, visitor.Value && {
            Map: visitor.Value,
            Scalar: visitor.Value,
            Seq: visitor.Value
        }, visitor.Collection && {
            Map: visitor.Collection,
            Seq: visitor.Collection
        }, visitor);
    }
    return visitor;
}
function callVisitor(key, node, visitor, path5) {
    var _a, _b, _c, _d, _e;
    if (typeof visitor === "function") return visitor(key, node, path5);
    if (isMap(node)) return (_a = visitor.Map) == null ? void 0 : _a.call(visitor, key, node, path5);
    if (isSeq(node)) return (_b = visitor.Seq) == null ? void 0 : _b.call(visitor, key, node, path5);
    if (isPair(node)) return (_c = visitor.Pair) == null ? void 0 : _c.call(visitor, key, node, path5);
    if (isScalar(node)) return (_d = visitor.Scalar) == null ? void 0 : _d.call(visitor, key, node, path5);
    if (isAlias(node)) return (_e = visitor.Alias) == null ? void 0 : _e.call(visitor, key, node, path5);
    return void 0;
}
function replaceNode(key, path5, node) {
    const parent = path5[path5.length - 1];
    if (isCollection(parent)) {
        parent.items[key] = node;
    } else if (isPair(parent)) {
        if (key === "key") parent.key = node;
        else parent.value = node;
    } else if (isDocument(parent)) {
        parent.contents = node;
    } else {
        const pt = isAlias(parent) ? "alias" : "scalar";
        throw new Error(`Cannot replace node with ${pt} parent`);
    }
}
// ../../node_modules/yaml/browser/dist/doc/directives.js
var escapeChars = {
    "!": "%21",
    ",": "%2C",
    "[": "%5B",
    "]": "%5D",
    "{": "%7B",
    "}": "%7D"
};
var escapeTagName = (tn)=>tn.replace(/[!,[\]{}]/g, (ch)=>escapeChars[ch]);
var Directives = class _Directives {
    clone() {
        const copy = new _Directives(this.yaml, this.tags);
        copy.docStart = this.docStart;
        return copy;
    }
    /**
   * During parsing, get a Directives instance for the current document and
   * update the stream state according to the current version's spec.
   */ atDocument() {
        const res = new _Directives(this.yaml, this.tags);
        switch(this.yaml.version){
            case "1.1":
                this.atNextDocument = true;
                break;
            case "1.2":
                this.atNextDocument = false;
                this.yaml = {
                    explicit: _Directives.defaultYaml.explicit,
                    version: "1.2"
                };
                this.tags = Object.assign({}, _Directives.defaultTags);
                break;
        }
        return res;
    }
    /**
   * @param onError - May be called even if the action was successful
   * @returns `true` on success
   */ add(line, onError) {
        if (this.atNextDocument) {
            this.yaml = {
                explicit: _Directives.defaultYaml.explicit,
                version: "1.1"
            };
            this.tags = Object.assign({}, _Directives.defaultTags);
            this.atNextDocument = false;
        }
        const parts = line.trim().split(/[ \t]+/);
        const name = parts.shift();
        switch(name){
            case "%TAG":
                {
                    if (parts.length !== 2) {
                        onError(0, "%TAG directive should contain exactly two parts");
                        if (parts.length < 2) return false;
                    }
                    const [handle, prefix] = parts;
                    this.tags[handle] = prefix;
                    return true;
                }
            case "%YAML":
                {
                    this.yaml.explicit = true;
                    if (parts.length !== 1) {
                        onError(0, "%YAML directive should contain exactly one part");
                        return false;
                    }
                    const [version] = parts;
                    if (version === "1.1" || version === "1.2") {
                        this.yaml.version = version;
                        return true;
                    } else {
                        const isValid = /^\d+\.\d+$/.test(version);
                        onError(6, `Unsupported YAML version ${version}`, isValid);
                        return false;
                    }
                }
            default:
                onError(0, `Unknown directive ${name}`, true);
                return false;
        }
    }
    /**
   * Resolves a tag, matching handles to those defined in %TAG directives.
   *
   * @returns Resolved tag, which may also be the non-specific tag `'!'` or a
   *   `'!local'` tag, or `null` if unresolvable.
   */ tagName(source, onError) {
        if (source === "!") return "!";
        if (source[0] !== "!") {
            onError(`Not a valid tag: ${source}`);
            return null;
        }
        if (source[1] === "<") {
            const verbatim = source.slice(2, -1);
            if (verbatim === "!" || verbatim === "!!") {
                onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);
                return null;
            }
            if (source[source.length - 1] !== ">") onError("Verbatim tags must end with a >");
            return verbatim;
        }
        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/);
        if (!suffix) onError(`The ${source} tag has no suffix`);
        const prefix = this.tags[handle];
        if (prefix) return prefix + decodeURIComponent(suffix);
        if (handle === "!") return source;
        onError(`Could not resolve tag: ${source}`);
        return null;
    }
    /**
   * Given a fully resolved tag, returns its printable string form,
   * taking into account current tag prefixes and defaults.
   */ tagString(tag) {
        for (const [handle, prefix] of Object.entries(this.tags)){
            if (tag.startsWith(prefix)) return handle + escapeTagName(tag.substring(prefix.length));
        }
        return tag[0] === "!" ? tag : `!<${tag}>`;
    }
    toString(doc) {
        const lines = this.yaml.explicit ? [
            `%YAML ${this.yaml.version || "1.2"}`
        ] : [];
        const tagEntries = Object.entries(this.tags);
        let tagNames;
        if (doc && tagEntries.length > 0 && isNode(doc.contents)) {
            const tags = {};
            visit2(doc.contents, (_key, node)=>{
                if (isNode(node) && node.tag) tags[node.tag] = true;
            });
            tagNames = Object.keys(tags);
        } else tagNames = [];
        for (const [handle, prefix] of tagEntries){
            if (handle === "!!" && prefix === "tag:yaml.org,2002:") continue;
            if (!doc || tagNames.some((tn)=>tn.startsWith(prefix))) lines.push(`%TAG ${handle} ${prefix}`);
        }
        return lines.join("\n");
    }
    constructor(yaml, tags){
        this.docStart = null;
        this.docEnd = false;
        this.yaml = Object.assign({}, _Directives.defaultYaml, yaml);
        this.tags = Object.assign({}, _Directives.defaultTags, tags);
    }
};
Directives.defaultYaml = {
    explicit: false,
    version: "1.2"
};
Directives.defaultTags = {
    "!!": "tag:yaml.org,2002:"
};
// ../../node_modules/yaml/browser/dist/doc/anchors.js
function anchorIsValid(anchor) {
    if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
        const sa = JSON.stringify(anchor);
        const msg = `Anchor must not contain whitespace or control characters: ${sa}`;
        throw new Error(msg);
    }
    return true;
}
function anchorNames(root) {
    const anchors = /* @__PURE__ */ new Set();
    visit2(root, {
        Value (_key, node) {
            if (node.anchor) anchors.add(node.anchor);
        }
    });
    return anchors;
}
function findNewAnchor(prefix, exclude) {
    for(let i = 1; true; ++i){
        const name = `${prefix}${i}`;
        if (!exclude.has(name)) return name;
    }
}
function createNodeAnchors(doc, prefix) {
    const aliasObjects = [];
    const sourceObjects = /* @__PURE__ */ new Map();
    let prevAnchors = null;
    return {
        onAnchor: (source)=>{
            aliasObjects.push(source);
            if (!prevAnchors) prevAnchors = anchorNames(doc);
            const anchor = findNewAnchor(prefix, prevAnchors);
            prevAnchors.add(anchor);
            return anchor;
        },
        /**
     * With circular references, the source node is only resolved after all
     * of its child nodes are. This is why anchors are set only after all of
     * the nodes have been created.
     */ setAnchors: ()=>{
            for (const source of aliasObjects){
                const ref = sourceObjects.get(source);
                if (typeof ref === "object" && ref.anchor && (isScalar(ref.node) || isCollection(ref.node))) {
                    ref.node.anchor = ref.anchor;
                } else {
                    const error = new Error("Failed to resolve repeated object (this should not happen)");
                    error.source = source;
                    throw error;
                }
            }
        },
        sourceObjects
    };
}
// ../../node_modules/yaml/browser/dist/nodes/Alias.js
var Alias = class extends NodeBase {
    /**
   * Resolve the value of this alias within `doc`, finding the last
   * instance of the `source` anchor before this node.
   */ resolve(doc) {
        let found = void 0;
        visit2(doc, {
            Node: (_key, node)=>{
                if (node === this) return visit2.BREAK;
                if (node.anchor === this.source) found = node;
            }
        });
        return found;
    }
    toJSON(_arg, ctx) {
        if (!ctx) return {
            source: this.source
        };
        const { anchors, doc, maxAliasCount } = ctx;
        const source = this.resolve(doc);
        if (!source) {
            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
            throw new ReferenceError(msg);
        }
        const data = anchors.get(source);
        if (!data || data.res === void 0) {
            const msg = "This should not happen: Alias anchor was not resolved?";
            throw new ReferenceError(msg);
        }
        if (maxAliasCount >= 0) {
            data.count += 1;
            if (data.aliasCount === 0) data.aliasCount = getAliasCount(doc, source, anchors);
            if (data.count * data.aliasCount > maxAliasCount) {
                const msg = "Excessive alias count indicates a resource exhaustion attack";
                throw new ReferenceError(msg);
            }
        }
        return data.res;
    }
    toString(ctx, _onComment, _onChompKeep) {
        const src = `*${this.source}`;
        if (ctx) {
            anchorIsValid(this.source);
            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
                throw new Error(msg);
            }
            if (ctx.implicitKey) return `${src} `;
        }
        return src;
    }
    constructor(source){
        super(ALIAS);
        this.source = source;
        Object.defineProperty(this, "tag", {
            set () {
                throw new Error("Alias nodes cannot have tags");
            }
        });
    }
};
function getAliasCount(doc, node, anchors) {
    if (isAlias(node)) {
        const source = node.resolve(doc);
        const anchor = anchors && source && anchors.get(source);
        return anchor ? anchor.count * anchor.aliasCount : 0;
    } else if (isCollection(node)) {
        let count = 0;
        for (const item of node.items){
            const c = getAliasCount(doc, item, anchors);
            if (c > count) count = c;
        }
        return count;
    } else if (isPair(node)) {
        const kc = getAliasCount(doc, node.key, anchors);
        const vc = getAliasCount(doc, node.value, anchors);
        return Math.max(kc, vc);
    }
    return 1;
}
// ../../node_modules/yaml/browser/dist/nodes/toJS.js
function toJS(value1, arg, ctx) {
    if (Array.isArray(value1)) return value1.map((v, i)=>toJS(v, String(i), ctx));
    if (value1 && typeof value1.toJSON === "function") {
        if (!ctx || !hasAnchor(value1)) return value1.toJSON(arg, ctx);
        const data = {
            aliasCount: 0,
            count: 1,
            res: void 0
        };
        ctx.anchors.set(value1, data);
        ctx.onCreate = (res2)=>{
            data.res = res2;
            delete ctx.onCreate;
        };
        const res = value1.toJSON(arg, ctx);
        if (ctx.onCreate) ctx.onCreate(res);
        return res;
    }
    if (typeof value1 === "bigint" && !(ctx == null ? void 0 : ctx.keep)) return Number(value1);
    return value1;
}
// ../../node_modules/yaml/browser/dist/nodes/Scalar.js
var isScalarValue = (value1)=>!value1 || typeof value1 !== "function" && typeof value1 !== "object";
var Scalar = class extends NodeBase {
    toJSON(arg, ctx) {
        return (ctx == null ? void 0 : ctx.keep) ? this.value : toJS(this.value, arg, ctx);
    }
    toString() {
        return String(this.value);
    }
    constructor(value1){
        super(SCALAR);
        this.value = value1;
    }
};
Scalar.BLOCK_FOLDED = "BLOCK_FOLDED";
Scalar.BLOCK_LITERAL = "BLOCK_LITERAL";
Scalar.PLAIN = "PLAIN";
Scalar.QUOTE_DOUBLE = "QUOTE_DOUBLE";
Scalar.QUOTE_SINGLE = "QUOTE_SINGLE";
// ../../node_modules/yaml/browser/dist/doc/createNode.js
var defaultTagPrefix = "tag:yaml.org,2002:";
function findTagObject(value1, tagName, tags) {
    var _a;
    if (tagName) {
        const match = tags.filter((t1)=>t1.tag === tagName);
        const tagObj = (_a = match.find((t1)=>!t1.format)) != null ? _a : match[0];
        if (!tagObj) throw new Error(`Tag ${tagName} not found`);
        return tagObj;
    }
    return tags.find((t1)=>{
        var _a2;
        return ((_a2 = t1.identify) == null ? void 0 : _a2.call(t1, value1)) && !t1.format;
    });
}
function createNode(value1, tagName, ctx) {
    var _a, _b;
    if (isDocument(value1)) value1 = value1.contents;
    if (isNode(value1)) return value1;
    if (isPair(value1)) {
        const map2 = (_b = (_a = ctx.schema[MAP]).createNode) == null ? void 0 : _b.call(_a, ctx.schema, null, ctx);
        map2.items.push(value1);
        return map2;
    }
    if (value1 instanceof String || value1 instanceof Number || value1 instanceof Boolean || typeof BigInt !== "undefined" && value1 instanceof BigInt) {
        value1 = value1.valueOf();
    }
    const { aliasDuplicateObjects, onAnchor, onTagObj, schema: schema4, sourceObjects } = ctx;
    let ref = void 0;
    if (aliasDuplicateObjects && value1 && typeof value1 === "object") {
        ref = sourceObjects.get(value1);
        if (ref) {
            if (!ref.anchor) ref.anchor = onAnchor(value1);
            return new Alias(ref.anchor);
        } else {
            ref = {
                anchor: null,
                node: null
            };
            sourceObjects.set(value1, ref);
        }
    }
    if (tagName == null ? void 0 : tagName.startsWith("!!")) tagName = defaultTagPrefix + tagName.slice(2);
    let tagObj = findTagObject(value1, tagName, schema4.tags);
    if (!tagObj) {
        if (value1 && typeof value1.toJSON === "function") {
            value1 = value1.toJSON();
        }
        if (!value1 || typeof value1 !== "object") {
            const node2 = new Scalar(value1);
            if (ref) ref.node = node2;
            return node2;
        }
        tagObj = value1 instanceof Map ? schema4[MAP] : Symbol.iterator in Object(value1) ? schema4[SEQ] : schema4[MAP];
    }
    if (onTagObj) {
        onTagObj(tagObj);
        delete ctx.onTagObj;
    }
    const node = (tagObj == null ? void 0 : tagObj.createNode) ? tagObj.createNode(ctx.schema, value1, ctx) : new Scalar(value1);
    if (tagName) node.tag = tagName;
    if (ref) ref.node = node;
    return node;
}
// ../../node_modules/yaml/browser/dist/nodes/Collection.js
function collectionFromPath(schema4, path5, value1) {
    let v = value1;
    for(let i = path5.length - 1; i >= 0; --i){
        const k = path5[i];
        if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
            const a2 = [];
            a2[k] = v;
            v = a2;
        } else {
            v = /* @__PURE__ */ new Map([
                [
                    k,
                    v
                ]
            ]);
        }
    }
    return createNode(v, void 0, {
        aliasDuplicateObjects: false,
        keepUndefined: false,
        onAnchor: ()=>{
            throw new Error("This should not happen, please report a bug.");
        },
        schema: schema4,
        sourceObjects: /* @__PURE__ */ new Map()
    });
}
var isEmptyPath = (path5)=>path5 == null || typeof path5 === "object" && !!path5[Symbol.iterator]().next().done;
var Collection = class extends NodeBase {
    /**
   * Create a copy of this collection.
   *
   * @param schema - If defined, overwrites the original's schema
   */ clone(schema4) {
        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
        if (schema4) copy.schema = schema4;
        copy.items = copy.items.map((it)=>isNode(it) || isPair(it) ? it.clone(schema4) : it);
        if (this.range) copy.range = this.range.slice();
        return copy;
    }
    /**
   * Adds a value to the collection. For `!!map` and `!!omap` the value must
   * be a Pair instance or a `{ key, value }` object, which may not have a key
   * that already exists in the map.
   */ addIn(path5, value1) {
        if (isEmptyPath(path5)) this.add(value1);
        else {
            const [key, ...rest] = path5;
            const node = this.get(key, true);
            if (isCollection(node)) node.addIn(rest, value1);
            else if (node === void 0 && this.schema) this.set(key, collectionFromPath(this.schema, rest, value1));
            else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
        }
    }
    /**
   * Removes a value from the collection.
   * @returns `true` if the item was found and removed.
   */ deleteIn(path5) {
        const [key, ...rest] = path5;
        if (rest.length === 0) return this.delete(key);
        const node = this.get(key, true);
        if (isCollection(node)) return node.deleteIn(rest);
        else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
    }
    /**
   * Returns item at `key`, or `undefined` if not found. By default unwraps
   * scalar values from their surrounding node; to disable set `keepScalar` to
   * `true` (collections are always returned intact).
   */ getIn(path5, keepScalar) {
        const [key, ...rest] = path5;
        const node = this.get(key, true);
        if (rest.length === 0) return !keepScalar && isScalar(node) ? node.value : node;
        else return isCollection(node) ? node.getIn(rest, keepScalar) : void 0;
    }
    hasAllNullValues(allowScalar) {
        return this.items.every((node)=>{
            if (!isPair(node)) return false;
            const n = node.value;
            return n == null || allowScalar && isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
        });
    }
    /**
   * Checks if the collection includes a value with the key `key`.
   */ hasIn(path5) {
        const [key, ...rest] = path5;
        if (rest.length === 0) return this.has(key);
        const node = this.get(key, true);
        return isCollection(node) ? node.hasIn(rest) : false;
    }
    /**
   * Sets a value in this collection. For `!!set`, `value` needs to be a
   * boolean to add/remove the item from the set.
   */ setIn(path5, value1) {
        const [key, ...rest] = path5;
        if (rest.length === 0) {
            this.set(key, value1);
        } else {
            const node = this.get(key, true);
            if (isCollection(node)) node.setIn(rest, value1);
            else if (node === void 0 && this.schema) this.set(key, collectionFromPath(this.schema, rest, value1));
            else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
        }
    }
    constructor(type, schema4){
        super(type);
        Object.defineProperty(this, "schema", {
            value: schema4,
            configurable: true,
            enumerable: false,
            writable: true
        });
    }
};
Collection.maxFlowStringSingleLineLength = 60;
// ../../node_modules/yaml/browser/dist/stringify/stringifyComment.js
var stringifyComment = (str)=>str.replace(/^(?!$)(?: $)?/gm, "#");
function indentComment(comment, indent) {
    if (/^\n+$/.test(comment)) return comment.substring(1);
    return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
}
var lineComment = (str, indent, comment)=>str.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str.endsWith(" ") ? "" : " ") + comment;
// ../../node_modules/yaml/browser/dist/stringify/foldFlowLines.js
var FOLD_FLOW = "flow";
var FOLD_BLOCK = "block";
var FOLD_QUOTED = "quoted";
function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {
    if (!lineWidth || lineWidth < 0) return text;
    const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
    if (text.length <= endStep) return text;
    const folds = [];
    const escapedFolds = {};
    let end = lineWidth - indent.length;
    if (typeof indentAtStart === "number") {
        if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0);
        else end = lineWidth - indentAtStart;
    }
    let split = void 0;
    let prev = void 0;
    let overflow = false;
    let i = -1;
    let escStart = -1;
    let escEnd = -1;
    if (mode === FOLD_BLOCK) {
        i = consumeMoreIndentedLines(text, i);
        if (i !== -1) end = i + endStep;
    }
    for(let ch; ch = text[i += 1];){
        if (mode === FOLD_QUOTED && ch === "\\") {
            escStart = i;
            switch(text[i + 1]){
                case "x":
                    i += 3;
                    break;
                case "u":
                    i += 5;
                    break;
                case "U":
                    i += 9;
                    break;
                default:
                    i += 1;
            }
            escEnd = i;
        }
        if (ch === "\n") {
            if (mode === FOLD_BLOCK) i = consumeMoreIndentedLines(text, i);
            end = i + endStep;
            split = void 0;
        } else {
            if (ch === " " && prev && prev !== " " && prev !== "\n" && prev !== "	") {
                const next = text[i + 1];
                if (next && next !== " " && next !== "\n" && next !== "	") split = i;
            }
            if (i >= end) {
                if (split) {
                    folds.push(split);
                    end = split + endStep;
                    split = void 0;
                } else if (mode === FOLD_QUOTED) {
                    while(prev === " " || prev === "	"){
                        prev = ch;
                        ch = text[i += 1];
                        overflow = true;
                    }
                    const j = i > escEnd + 1 ? i - 2 : escStart - 1;
                    if (escapedFolds[j]) return text;
                    folds.push(j);
                    escapedFolds[j] = true;
                    end = j + endStep;
                    split = void 0;
                } else {
                    overflow = true;
                }
            }
        }
        prev = ch;
    }
    if (overflow && onOverflow) onOverflow();
    if (folds.length === 0) return text;
    if (onFold) onFold();
    let res = text.slice(0, folds[0]);
    for(let i2 = 0; i2 < folds.length; ++i2){
        const fold = folds[i2];
        const end2 = folds[i2 + 1] || text.length;
        if (fold === 0) res = `
${indent}${text.slice(0, end2)}`;
        else {
            if (mode === FOLD_QUOTED && escapedFolds[fold]) res += `${text[fold]}\\`;
            res += `
${indent}${text.slice(fold + 1, end2)}`;
        }
    }
    return res;
}
function consumeMoreIndentedLines(text, i) {
    let ch = text[i + 1];
    while(ch === " " || ch === "	"){
        do {
            ch = text[i += 1];
        }while (ch && ch !== "\n")
        ch = text[i + 1];
    }
    return i;
}
// ../../node_modules/yaml/browser/dist/stringify/stringifyString.js
var getFoldOptions = (ctx, isBlock2)=>({
        indentAtStart: isBlock2 ? ctx.indent.length : ctx.indentAtStart,
        lineWidth: ctx.options.lineWidth,
        minContentWidth: ctx.options.minContentWidth
    });
var containsDocumentMarker = (str)=>/^(%|---|\.\.\.)/m.test(str);
function lineLengthOverLimit(str, lineWidth, indentLength) {
    if (!lineWidth || lineWidth < 0) return false;
    const limit = lineWidth - indentLength;
    const strLen = str.length;
    if (strLen <= limit) return false;
    for(let i = 0, start = 0; i < strLen; ++i){
        if (str[i] === "\n") {
            if (i - start > limit) return true;
            start = i + 1;
            if (strLen - start <= limit) return false;
        }
    }
    return true;
}
function doubleQuotedString(value1, ctx) {
    const json = JSON.stringify(value1);
    if (ctx.options.doubleQuotedAsJSON) return json;
    const { implicitKey } = ctx;
    const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;
    const indent = ctx.indent || (containsDocumentMarker(value1) ? "  " : "");
    let str = "";
    let start = 0;
    for(let i = 0, ch = json[i]; ch; ch = json[++i]){
        if (ch === " " && json[i + 1] === "\\" && json[i + 2] === "n") {
            str += json.slice(start, i) + "\\ ";
            i += 1;
            start = i;
            ch = "\\";
        }
        if (ch === "\\") switch(json[i + 1]){
            case "u":
                {
                    str += json.slice(start, i);
                    const code = json.substr(i + 2, 4);
                    switch(code){
                        case "0000":
                            str += "\\0";
                            break;
                        case "0007":
                            str += "\\a";
                            break;
                        case "000b":
                            str += "\\v";
                            break;
                        case "001b":
                            str += "\\e";
                            break;
                        case "0085":
                            str += "\\N";
                            break;
                        case "00a0":
                            str += "\\_";
                            break;
                        case "2028":
                            str += "\\L";
                            break;
                        case "2029":
                            str += "\\P";
                            break;
                        default:
                            if (code.substr(0, 2) === "00") str += "\\x" + code.substr(2);
                            else str += json.substr(i, 6);
                    }
                    i += 5;
                    start = i + 1;
                }
                break;
            case "n":
                if (implicitKey || json[i + 2] === '"' || json.length < minMultiLineLength) {
                    i += 1;
                } else {
                    str += json.slice(start, i) + "\n\n";
                    while(json[i + 2] === "\\" && json[i + 3] === "n" && json[i + 4] !== '"'){
                        str += "\n";
                        i += 2;
                    }
                    str += indent;
                    if (json[i + 2] === " ") str += "\\";
                    i += 1;
                    start = i + 1;
                }
                break;
            default:
                i += 1;
        }
    }
    str = start ? str + json.slice(start) : json;
    return implicitKey ? str : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false));
}
function singleQuotedString(value1, ctx) {
    if (ctx.options.singleQuote === false || ctx.implicitKey && value1.includes("\n") || /[ \t]\n|\n[ \t]/.test(value1)) return doubleQuotedString(value1, ctx);
    const indent = ctx.indent || (containsDocumentMarker(value1) ? "  " : "");
    const res = "'" + value1.replace(/'/g, "''").replace(/\n+/g, `$&
${indent}`) + "'";
    return ctx.implicitKey ? res : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false));
}
function quotedString(value1, ctx) {
    const { singleQuote } = ctx.options;
    let qs;
    if (singleQuote === false) qs = doubleQuotedString;
    else {
        const hasDouble = value1.includes('"');
        const hasSingle = value1.includes("'");
        if (hasDouble && !hasSingle) qs = singleQuotedString;
        else if (hasSingle && !hasDouble) qs = doubleQuotedString;
        else qs = singleQuote ? singleQuotedString : doubleQuotedString;
    }
    return qs(value1, ctx);
}
function blockString({ comment, type, value: value1 }, ctx, onComment, onChompKeep) {
    const { blockQuote, commentString, lineWidth } = ctx.options;
    if (!blockQuote || /\n[\t ]+$/.test(value1) || /^\s*$/.test(value1)) {
        return quotedString(value1, ctx);
    }
    const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value1) ? "  " : "");
    const literal = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.BLOCK_FOLDED ? false : type === Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value1, lineWidth, indent.length);
    if (!value1) return literal ? "|\n" : ">\n";
    let chomp;
    let endStart;
    for(endStart = value1.length; endStart > 0; --endStart){
        const ch = value1[endStart - 1];
        if (ch !== "\n" && ch !== "	" && ch !== " ") break;
    }
    let end = value1.substring(endStart);
    const endNlPos = end.indexOf("\n");
    if (endNlPos === -1) {
        chomp = "-";
    } else if (value1 === end || endNlPos !== end.length - 1) {
        chomp = "+";
        if (onChompKeep) onChompKeep();
    } else {
        chomp = "";
    }
    if (end) {
        value1 = value1.slice(0, -end.length);
        if (end[end.length - 1] === "\n") end = end.slice(0, -1);
        end = end.replace(/\n+(?!\n|$)/g, `$&${indent}`);
    }
    let startWithSpace = false;
    let startEnd;
    let startNlPos = -1;
    for(startEnd = 0; startEnd < value1.length; ++startEnd){
        const ch = value1[startEnd];
        if (ch === " ") startWithSpace = true;
        else if (ch === "\n") startNlPos = startEnd;
        else break;
    }
    let start = value1.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
    if (start) {
        value1 = value1.substring(start.length);
        start = start.replace(/\n+/g, `$&${indent}`);
    }
    const indentSize = indent ? "2" : "1";
    let header = (literal ? "|" : ">") + (startWithSpace ? indentSize : "") + chomp;
    if (comment) {
        header += " " + commentString(comment.replace(/ ?[\r\n]+/g, " "));
        if (onComment) onComment();
    }
    if (literal) {
        value1 = value1.replace(/\n+/g, `$&${indent}`);
        return `${header}
${indent}${start}${value1}${end}`;
    }
    value1 = value1.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`);
    const body = foldFlowLines(`${start}${value1}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx, true));
    return `${header}
${indent}${body}`;
}
function plainString(item, ctx, onComment, onChompKeep) {
    const { type, value: value1 } = item;
    const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;
    if (implicitKey && /[\n[\]{},]/.test(value1) || inFlow && /[[\]{},]/.test(value1)) {
        return quotedString(value1, ctx);
    }
    if (!value1 || /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value1)) {
        return implicitKey || inFlow || !value1.includes("\n") ? quotedString(value1, ctx) : blockString(item, ctx, onComment, onChompKeep);
    }
    if (!implicitKey && !inFlow && type !== Scalar.PLAIN && value1.includes("\n")) {
        return blockString(item, ctx, onComment, onChompKeep);
    }
    if (containsDocumentMarker(value1)) {
        if (indent === "") {
            ctx.forceBlockIndent = true;
            return blockString(item, ctx, onComment, onChompKeep);
        } else if (implicitKey && indent === indentStep) {
            return quotedString(value1, ctx);
        }
    }
    const str = value1.replace(/\n+/g, `$&
${indent}`);
    if (actualString) {
        const test = (tag)=>{
            var _a;
            return tag.default && tag.tag !== "tag:yaml.org,2002:str" && ((_a = tag.test) == null ? void 0 : _a.test(str));
        };
        const { compat, tags } = ctx.doc.schema;
        if (tags.some(test) || (compat == null ? void 0 : compat.some(test))) return quotedString(value1, ctx);
    }
    return implicitKey ? str : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false));
}
function stringifyString(item, ctx, onComment, onChompKeep) {
    const { implicitKey, inFlow } = ctx;
    const ss = typeof item.value === "string" ? item : Object.assign({}, item, {
        value: String(item.value)
    });
    let { type } = item;
    if (type !== Scalar.QUOTE_DOUBLE) {
        if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value)) type = Scalar.QUOTE_DOUBLE;
    }
    const _stringify = (_type)=>{
        switch(_type){
            case Scalar.BLOCK_FOLDED:
            case Scalar.BLOCK_LITERAL:
                return implicitKey || inFlow ? quotedString(ss.value, ctx) : blockString(ss, ctx, onComment, onChompKeep);
            case Scalar.QUOTE_DOUBLE:
                return doubleQuotedString(ss.value, ctx);
            case Scalar.QUOTE_SINGLE:
                return singleQuotedString(ss.value, ctx);
            case Scalar.PLAIN:
                return plainString(ss, ctx, onComment, onChompKeep);
            default:
                return null;
        }
    };
    let res = _stringify(type);
    if (res === null) {
        const { defaultKeyType, defaultStringType } = ctx.options;
        const t1 = implicitKey && defaultKeyType || defaultStringType;
        res = _stringify(t1);
        if (res === null) throw new Error(`Unsupported default string type ${t1}`);
    }
    return res;
}
// ../../node_modules/yaml/browser/dist/stringify/stringify.js
function createStringifyContext(doc, options) {
    const opt = Object.assign({
        blockQuote: true,
        commentString: stringifyComment,
        defaultKeyType: null,
        defaultStringType: "PLAIN",
        directives: null,
        doubleQuotedAsJSON: false,
        doubleQuotedMinMultiLineLength: 40,
        falseStr: "false",
        flowCollectionPadding: true,
        indentSeq: true,
        lineWidth: 80,
        minContentWidth: 20,
        nullStr: "null",
        simpleKeys: false,
        singleQuote: null,
        trueStr: "true",
        verifyAliasOrder: true
    }, doc.schema.toStringOptions, options);
    let inFlow;
    switch(opt.collectionStyle){
        case "block":
            inFlow = false;
            break;
        case "flow":
            inFlow = true;
            break;
        default:
            inFlow = null;
    }
    return {
        anchors: /* @__PURE__ */ new Set(),
        doc,
        flowCollectionPadding: opt.flowCollectionPadding ? " " : "",
        indent: "",
        indentStep: typeof opt.indent === "number" ? " ".repeat(opt.indent) : "  ",
        inFlow,
        options: opt
    };
}
function getTagObject(tags, item) {
    var _a, _b, _c, _d;
    if (item.tag) {
        const match = tags.filter((t1)=>t1.tag === item.tag);
        if (match.length > 0) return (_a = match.find((t1)=>t1.format === item.format)) != null ? _a : match[0];
    }
    let tagObj = void 0;
    let obj;
    if (isScalar(item)) {
        obj = item.value;
        const match = tags.filter((t1)=>{
            var _a2;
            return (_a2 = t1.identify) == null ? void 0 : _a2.call(t1, obj);
        });
        tagObj = (_b = match.find((t1)=>t1.format === item.format)) != null ? _b : match.find((t1)=>!t1.format);
    } else {
        obj = item;
        tagObj = tags.find((t1)=>t1.nodeClass && obj instanceof t1.nodeClass);
    }
    if (!tagObj) {
        const name = (_d = (_c = obj == null ? void 0 : obj.constructor) == null ? void 0 : _c.name) != null ? _d : typeof obj;
        throw new Error(`Tag not resolved for ${name} value`);
    }
    return tagObj;
}
function stringifyProps(node, tagObj, { anchors, doc }) {
    if (!doc.directives) return "";
    const props = [];
    const anchor = (isScalar(node) || isCollection(node)) && node.anchor;
    if (anchor && anchorIsValid(anchor)) {
        anchors.add(anchor);
        props.push(`&${anchor}`);
    }
    const tag = node.tag ? node.tag : tagObj.default ? null : tagObj.tag;
    if (tag) props.push(doc.directives.tagString(tag));
    return props.join(" ");
}
function stringify(item, ctx, onComment, onChompKeep) {
    var _a, _b;
    if (isPair(item)) return item.toString(ctx, onComment, onChompKeep);
    if (isAlias(item)) {
        if (ctx.doc.directives) return item.toString(ctx);
        if ((_a = ctx.resolvedAliases) == null ? void 0 : _a.has(item)) {
            throw new TypeError(`Cannot stringify circular structure without alias nodes`);
        } else {
            if (ctx.resolvedAliases) ctx.resolvedAliases.add(item);
            else ctx.resolvedAliases = /* @__PURE__ */ new Set([
                item
            ]);
            item = item.resolve(ctx.doc);
        }
    }
    let tagObj = void 0;
    const node = isNode(item) ? item : ctx.doc.createNode(item, {
        onTagObj: (o)=>tagObj = o
    });
    if (!tagObj) tagObj = getTagObject(ctx.doc.schema.tags, node);
    const props = stringifyProps(node, tagObj, ctx);
    if (props.length > 0) ctx.indentAtStart = ((_b = ctx.indentAtStart) != null ? _b : 0) + props.length + 1;
    const str = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : isScalar(node) ? stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
    if (!props) return str;
    return isScalar(node) || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props}
${ctx.indent}${str}`;
}
// ../../node_modules/yaml/browser/dist/stringify/stringifyPair.js
function stringifyPair({ key, value: value1 }, ctx, onComment, onChompKeep) {
    var _a, _b;
    const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
    let keyComment = isNode(key) && key.comment || null;
    if (simpleKeys) {
        if (keyComment) {
            throw new Error("With simple keys, key nodes cannot have comments");
        }
        if (isCollection(key)) {
            const msg = "With simple keys, collection cannot be used as a key value";
            throw new Error(msg);
        }
    }
    let explicitKey = !simpleKeys && (!key || keyComment && value1 == null && !ctx.inFlow || isCollection(key) || (isScalar(key) ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL : typeof key === "object"));
    ctx = Object.assign({}, ctx, {
        allNullValues: false,
        implicitKey: !explicitKey && (simpleKeys || !allNullValues),
        indent: indent + indentStep
    });
    let keyCommentDone = false;
    let chompKeep = false;
    let str = stringify(key, ctx, ()=>keyCommentDone = true, ()=>chompKeep = true);
    if (!explicitKey && !ctx.inFlow && str.length > 1024) {
        if (simpleKeys) throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
        explicitKey = true;
    }
    if (ctx.inFlow) {
        if (allNullValues || value1 == null) {
            if (keyCommentDone && onComment) onComment();
            return str === "" ? "?" : explicitKey ? `? ${str}` : str;
        }
    } else if (allNullValues && !simpleKeys || value1 == null && explicitKey) {
        str = `? ${str}`;
        if (keyComment && !keyCommentDone) {
            str += lineComment(str, ctx.indent, commentString(keyComment));
        } else if (chompKeep && onChompKeep) onChompKeep();
        return str;
    }
    if (keyCommentDone) keyComment = null;
    if (explicitKey) {
        if (keyComment) str += lineComment(str, ctx.indent, commentString(keyComment));
        str = `? ${str}
${indent}:`;
    } else {
        str = `${str}:`;
        if (keyComment) str += lineComment(str, ctx.indent, commentString(keyComment));
    }
    let vsb, vcb, valueComment;
    if (isNode(value1)) {
        vsb = !!value1.spaceBefore;
        vcb = value1.commentBefore;
        valueComment = value1.comment;
    } else {
        vsb = false;
        vcb = null;
        valueComment = null;
        if (value1 && typeof value1 === "object") value1 = doc.createNode(value1);
    }
    ctx.implicitKey = false;
    if (!explicitKey && !keyComment && isScalar(value1)) ctx.indentAtStart = str.length + 1;
    chompKeep = false;
    if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && isSeq(value1) && !value1.flow && !value1.tag && !value1.anchor) {
        ctx.indent = ctx.indent.substring(2);
    }
    let valueCommentDone = false;
    const valueStr = stringify(value1, ctx, ()=>valueCommentDone = true, ()=>chompKeep = true);
    let ws = " ";
    if (keyComment || vsb || vcb) {
        ws = vsb ? "\n" : "";
        if (vcb) {
            const cs = commentString(vcb);
            ws += `
${indentComment(cs, ctx.indent)}`;
        }
        if (valueStr === "" && !ctx.inFlow) {
            if (ws === "\n") ws = "\n\n";
        } else {
            ws += `
${ctx.indent}`;
        }
    } else if (!explicitKey && isCollection(value1)) {
        const vs0 = valueStr[0];
        const nl0 = valueStr.indexOf("\n");
        const hasNewline = nl0 !== -1;
        const flow = (_b = (_a = ctx.inFlow) != null ? _a : value1.flow) != null ? _b : value1.items.length === 0;
        if (hasNewline || !flow) {
            let hasPropsLine = false;
            if (hasNewline && (vs0 === "&" || vs0 === "!")) {
                let sp0 = valueStr.indexOf(" ");
                if (vs0 === "&" && sp0 !== -1 && sp0 < nl0 && valueStr[sp0 + 1] === "!") {
                    sp0 = valueStr.indexOf(" ", sp0 + 1);
                }
                if (sp0 === -1 || nl0 < sp0) hasPropsLine = true;
            }
            if (!hasPropsLine) ws = `
${ctx.indent}`;
        }
    } else if (valueStr === "" || valueStr[0] === "\n") {
        ws = "";
    }
    str += ws + valueStr;
    if (ctx.inFlow) {
        if (valueCommentDone && onComment) onComment();
    } else if (valueComment && !valueCommentDone) {
        str += lineComment(str, ctx.indent, commentString(valueComment));
    } else if (chompKeep && onChompKeep) {
        onChompKeep();
    }
    return str;
}
// ../../node_modules/yaml/browser/dist/log.js
function warn(logLevel, warning) {
    if (logLevel === "debug" || logLevel === "warn") {
        if (typeof process !== "undefined" && process.emitWarning) process.emitWarning(warning);
        else console.warn(warning);
    }
}
// ../../node_modules/yaml/browser/dist/nodes/addPairToJSMap.js
var MERGE_KEY = "<<";
function addPairToJSMap(ctx, map2, { key, value: value1 }) {
    if ((ctx == null ? void 0 : ctx.doc.schema.merge) && isMergeKey(key)) {
        value1 = isAlias(value1) ? value1.resolve(ctx.doc) : value1;
        if (isSeq(value1)) for (const it of value1.items)mergeToJSMap(ctx, map2, it);
        else if (Array.isArray(value1)) for (const it of value1)mergeToJSMap(ctx, map2, it);
        else mergeToJSMap(ctx, map2, value1);
    } else {
        const jsKey = toJS(key, "", ctx);
        if (map2 instanceof Map) {
            map2.set(jsKey, toJS(value1, jsKey, ctx));
        } else if (map2 instanceof Set) {
            map2.add(jsKey);
        } else {
            const stringKey = stringifyKey(key, jsKey, ctx);
            const jsValue = toJS(value1, stringKey, ctx);
            if (stringKey in map2) Object.defineProperty(map2, stringKey, {
                value: jsValue,
                writable: true,
                enumerable: true,
                configurable: true
            });
            else map2[stringKey] = jsValue;
        }
    }
    return map2;
}
var isMergeKey = (key)=>key === MERGE_KEY || isScalar(key) && key.value === MERGE_KEY && (!key.type || key.type === Scalar.PLAIN);
function mergeToJSMap(ctx, map2, value1) {
    const source = ctx && isAlias(value1) ? value1.resolve(ctx.doc) : value1;
    if (!isMap(source)) throw new Error("Merge sources must be maps or map aliases");
    const srcMap = source.toJSON(null, ctx, Map);
    for (const [key, value2] of srcMap){
        if (map2 instanceof Map) {
            if (!map2.has(key)) map2.set(key, value2);
        } else if (map2 instanceof Set) {
            map2.add(key);
        } else if (!Object.prototype.hasOwnProperty.call(map2, key)) {
            Object.defineProperty(map2, key, {
                value: value2,
                writable: true,
                enumerable: true,
                configurable: true
            });
        }
    }
    return map2;
}
function stringifyKey(key, jsKey, ctx) {
    if (jsKey === null) return "";
    if (typeof jsKey !== "object") return String(jsKey);
    if (isNode(key) && ctx && ctx.doc) {
        const strCtx = createStringifyContext(ctx.doc, {});
        strCtx.anchors = /* @__PURE__ */ new Set();
        for (const node of ctx.anchors.keys())strCtx.anchors.add(node.anchor);
        strCtx.inFlow = true;
        strCtx.inStringifyKey = true;
        const strKey = key.toString(strCtx);
        if (!ctx.mapKeyWarned) {
            let jsonStr = JSON.stringify(strKey);
            if (jsonStr.length > 40) jsonStr = jsonStr.substring(0, 36) + '..."';
            warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
            ctx.mapKeyWarned = true;
        }
        return strKey;
    }
    return JSON.stringify(jsKey);
}
// ../../node_modules/yaml/browser/dist/nodes/Pair.js
function createPair(key, value1, ctx) {
    const k = createNode(key, void 0, ctx);
    const v = createNode(value1, void 0, ctx);
    return new Pair(k, v);
}
var Pair = class _Pair {
    clone(schema4) {
        let { key, value: value1 } = this;
        if (isNode(key)) key = key.clone(schema4);
        if (isNode(value1)) value1 = value1.clone(schema4);
        return new _Pair(key, value1);
    }
    toJSON(_2, ctx) {
        const pair = (ctx == null ? void 0 : ctx.mapAsMap) ? /* @__PURE__ */ new Map() : {};
        return addPairToJSMap(ctx, pair, this);
    }
    toString(ctx, onComment, onChompKeep) {
        return (ctx == null ? void 0 : ctx.doc) ? stringifyPair(this, ctx, onComment, onChompKeep) : JSON.stringify(this);
    }
    constructor(key, value1 = null){
        Object.defineProperty(this, NODE_TYPE, {
            value: PAIR
        });
        this.key = key;
        this.value = value1;
    }
};
// ../../node_modules/yaml/browser/dist/stringify/stringifyCollection.js
function stringifyCollection(collection, ctx, options) {
    var _a;
    const flow = (_a = ctx.inFlow) != null ? _a : collection.flow;
    const stringify4 = flow ? stringifyFlowCollection : stringifyBlockCollection;
    return stringify4(collection, ctx, options);
}
function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {
    const { indent, options: { commentString } } = ctx;
    const itemCtx = Object.assign({}, ctx, {
        indent: itemIndent,
        type: null
    });
    let chompKeep = false;
    const lines = [];
    for(let i = 0; i < items.length; ++i){
        const item = items[i];
        let comment2 = null;
        if (isNode(item)) {
            if (!chompKeep && item.spaceBefore) lines.push("");
            addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
            if (item.comment) comment2 = item.comment;
        } else if (isPair(item)) {
            const ik = isNode(item.key) ? item.key : null;
            if (ik) {
                if (!chompKeep && ik.spaceBefore) lines.push("");
                addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);
            }
        }
        chompKeep = false;
        let str2 = stringify(item, itemCtx, ()=>comment2 = null, ()=>chompKeep = true);
        if (comment2) str2 += lineComment(str2, itemIndent, commentString(comment2));
        if (chompKeep && comment2) chompKeep = false;
        lines.push(blockItemPrefix + str2);
    }
    let str;
    if (lines.length === 0) {
        str = flowChars.start + flowChars.end;
    } else {
        str = lines[0];
        for(let i = 1; i < lines.length; ++i){
            const line = lines[i];
            str += line ? `
${indent}${line}` : "\n";
        }
    }
    if (comment) {
        str += "\n" + indentComment(commentString(comment), indent);
        if (onComment) onComment();
    } else if (chompKeep && onChompKeep) onChompKeep();
    return str;
}
function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemIndent, onComment }) {
    const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
    itemIndent += indentStep;
    const itemCtx = Object.assign({}, ctx, {
        indent: itemIndent,
        inFlow: true,
        type: null
    });
    let reqNewline = false;
    let linesAtValue = 0;
    const lines = [];
    for(let i = 0; i < items.length; ++i){
        const item = items[i];
        let comment2 = null;
        if (isNode(item)) {
            if (item.spaceBefore) lines.push("");
            addCommentBefore(ctx, lines, item.commentBefore, false);
            if (item.comment) comment2 = item.comment;
        } else if (isPair(item)) {
            const ik = isNode(item.key) ? item.key : null;
            if (ik) {
                if (ik.spaceBefore) lines.push("");
                addCommentBefore(ctx, lines, ik.commentBefore, false);
                if (ik.comment) reqNewline = true;
            }
            const iv = isNode(item.value) ? item.value : null;
            if (iv) {
                if (iv.comment) comment2 = iv.comment;
                if (iv.commentBefore) reqNewline = true;
            } else if (item.value == null && ik && ik.comment) {
                comment2 = ik.comment;
            }
        }
        if (comment2) reqNewline = true;
        let str2 = stringify(item, itemCtx, ()=>comment2 = null);
        if (i < items.length - 1) str2 += ",";
        if (comment2) str2 += lineComment(str2, itemIndent, commentString(comment2));
        if (!reqNewline && (lines.length > linesAtValue || str2.includes("\n"))) reqNewline = true;
        lines.push(str2);
        linesAtValue = lines.length;
    }
    let str;
    const { start, end } = flowChars;
    if (lines.length === 0) {
        str = start + end;
    } else {
        if (!reqNewline) {
            const len = lines.reduce((sum, line)=>sum + line.length + 2, 2);
            reqNewline = len > Collection.maxFlowStringSingleLineLength;
        }
        if (reqNewline) {
            str = start;
            for (const line of lines)str += line ? `
${indentStep}${indent}${line}` : "\n";
            str += `
${indent}${end}`;
        } else {
            str = `${start}${fcPadding}${lines.join(" ")}${fcPadding}${end}`;
        }
    }
    if (comment) {
        str += lineComment(str, indent, commentString(comment));
        if (onComment) onComment();
    }
    return str;
}
function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {
    if (comment && chompKeep) comment = comment.replace(/^\n+/, "");
    if (comment) {
        const ic = indentComment(commentString(comment), indent);
        lines.push(ic.trimStart());
    }
}
// ../../node_modules/yaml/browser/dist/nodes/YAMLMap.js
function findPair(items, key) {
    const k = isScalar(key) ? key.value : key;
    for (const it of items){
        if (isPair(it)) {
            if (it.key === key || it.key === k) return it;
            if (isScalar(it.key) && it.key.value === k) return it;
        }
    }
    return void 0;
}
var YAMLMap = class extends Collection {
    static get tagName() {
        return "tag:yaml.org,2002:map";
    }
    /**
   * Adds a value to the collection.
   *
   * @param overwrite - If not set `true`, using a key that is already in the
   *   collection will throw. Otherwise, overwrites the previous value.
   */ add(pair, overwrite) {
        var _a;
        let _pair;
        if (isPair(pair)) _pair = pair;
        else if (!pair || typeof pair !== "object" || !("key" in pair)) {
            _pair = new Pair(pair, pair == null ? void 0 : pair.value);
        } else _pair = new Pair(pair.key, pair.value);
        const prev = findPair(this.items, _pair.key);
        const sortEntries = (_a = this.schema) == null ? void 0 : _a.sortMapEntries;
        if (prev) {
            if (!overwrite) throw new Error(`Key ${_pair.key} already set`);
            if (isScalar(prev.value) && isScalarValue(_pair.value)) prev.value.value = _pair.value;
            else prev.value = _pair.value;
        } else if (sortEntries) {
            const i = this.items.findIndex((item)=>sortEntries(_pair, item) < 0);
            if (i === -1) this.items.push(_pair);
            else this.items.splice(i, 0, _pair);
        } else {
            this.items.push(_pair);
        }
    }
    delete(key) {
        const it = findPair(this.items, key);
        if (!it) return false;
        const del = this.items.splice(this.items.indexOf(it), 1);
        return del.length > 0;
    }
    get(key, keepScalar) {
        var _a;
        const it = findPair(this.items, key);
        const node = it == null ? void 0 : it.value;
        return (_a = !keepScalar && isScalar(node) ? node.value : node) != null ? _a : void 0;
    }
    has(key) {
        return !!findPair(this.items, key);
    }
    set(key, value1) {
        this.add(new Pair(key, value1), true);
    }
    /**
   * @param ctx - Conversion context, originally set in Document#toJS()
   * @param {Class} Type - If set, forces the returned collection type
   * @returns Instance of Type, Map, or Object
   */ toJSON(_2, ctx, Type) {
        const map2 = Type ? new Type() : (ctx == null ? void 0 : ctx.mapAsMap) ? /* @__PURE__ */ new Map() : {};
        if (ctx == null ? void 0 : ctx.onCreate) ctx.onCreate(map2);
        for (const item of this.items)addPairToJSMap(ctx, map2, item);
        return map2;
    }
    toString(ctx, onComment, onChompKeep) {
        if (!ctx) return JSON.stringify(this);
        for (const item of this.items){
            if (!isPair(item)) throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
        }
        if (!ctx.allNullValues && this.hasAllNullValues(false)) ctx = Object.assign({}, ctx, {
            allNullValues: true
        });
        return stringifyCollection(this, ctx, {
            blockItemPrefix: "",
            flowChars: {
                start: "{",
                end: "}"
            },
            itemIndent: ctx.indent || "",
            onChompKeep,
            onComment
        });
    }
    constructor(schema4){
        super(MAP, schema4);
        this.items = [];
    }
};
// ../../node_modules/yaml/browser/dist/schema/common/map.js
function createMap(schema4, obj, ctx) {
    const { keepUndefined, replacer } = ctx;
    const map2 = new YAMLMap(schema4);
    const add = (key, value1)=>{
        if (typeof replacer === "function") value1 = replacer.call(obj, key, value1);
        else if (Array.isArray(replacer) && !replacer.includes(key)) return;
        if (value1 !== void 0 || keepUndefined) map2.items.push(createPair(key, value1, ctx));
    };
    if (obj instanceof Map) {
        for (const [key, value1] of obj)add(key, value1);
    } else if (obj && typeof obj === "object") {
        for (const key of Object.keys(obj))add(key, obj[key]);
    }
    if (typeof schema4.sortMapEntries === "function") {
        map2.items.sort(schema4.sortMapEntries);
    }
    return map2;
}
var map = {
    collection: "map",
    createNode: createMap,
    default: true,
    nodeClass: YAMLMap,
    tag: "tag:yaml.org,2002:map",
    resolve (map2, onError) {
        if (!isMap(map2)) onError("Expected a mapping for this tag");
        return map2;
    }
};
// ../../node_modules/yaml/browser/dist/nodes/YAMLSeq.js
var YAMLSeq = class extends Collection {
    static get tagName() {
        return "tag:yaml.org,2002:seq";
    }
    add(value1) {
        this.items.push(value1);
    }
    /**
   * Removes a value from the collection.
   *
   * `key` must contain a representation of an integer for this to succeed.
   * It may be wrapped in a `Scalar`.
   *
   * @returns `true` if the item was found and removed.
   */ delete(key) {
        const idx = asItemIndex(key);
        if (typeof idx !== "number") return false;
        const del = this.items.splice(idx, 1);
        return del.length > 0;
    }
    get(key, keepScalar) {
        const idx = asItemIndex(key);
        if (typeof idx !== "number") return void 0;
        const it = this.items[idx];
        return !keepScalar && isScalar(it) ? it.value : it;
    }
    /**
   * Checks if the collection includes a value with the key `key`.
   *
   * `key` must contain a representation of an integer for this to succeed.
   * It may be wrapped in a `Scalar`.
   */ has(key) {
        const idx = asItemIndex(key);
        return typeof idx === "number" && idx < this.items.length;
    }
    /**
   * Sets a value in this collection. For `!!set`, `value` needs to be a
   * boolean to add/remove the item from the set.
   *
   * If `key` does not contain a representation of an integer, this will throw.
   * It may be wrapped in a `Scalar`.
   */ set(key, value1) {
        const idx = asItemIndex(key);
        if (typeof idx !== "number") throw new Error(`Expected a valid index, not ${key}.`);
        const prev = this.items[idx];
        if (isScalar(prev) && isScalarValue(value1)) prev.value = value1;
        else this.items[idx] = value1;
    }
    toJSON(_2, ctx) {
        const seq2 = [];
        if (ctx == null ? void 0 : ctx.onCreate) ctx.onCreate(seq2);
        let i = 0;
        for (const item of this.items)seq2.push(toJS(item, String(i++), ctx));
        return seq2;
    }
    toString(ctx, onComment, onChompKeep) {
        if (!ctx) return JSON.stringify(this);
        return stringifyCollection(this, ctx, {
            blockItemPrefix: "- ",
            flowChars: {
                start: "[",
                end: "]"
            },
            itemIndent: (ctx.indent || "") + "  ",
            onChompKeep,
            onComment
        });
    }
    constructor(schema4){
        super(SEQ, schema4);
        this.items = [];
    }
};
function asItemIndex(key) {
    let idx = isScalar(key) ? key.value : key;
    if (idx && typeof idx === "string") idx = Number(idx);
    return typeof idx === "number" && Number.isInteger(idx) && idx >= 0 ? idx : null;
}
// ../../node_modules/yaml/browser/dist/schema/common/seq.js
function createSeq(schema4, obj, ctx) {
    const { replacer } = ctx;
    const seq2 = new YAMLSeq(schema4);
    if (obj && Symbol.iterator in Object(obj)) {
        let i = 0;
        for (let it of obj){
            if (typeof replacer === "function") {
                const key = obj instanceof Set ? it : String(i++);
                it = replacer.call(obj, key, it);
            }
            seq2.items.push(createNode(it, void 0, ctx));
        }
    }
    return seq2;
}
var seq = {
    collection: "seq",
    createNode: createSeq,
    default: true,
    nodeClass: YAMLSeq,
    tag: "tag:yaml.org,2002:seq",
    resolve (seq2, onError) {
        if (!isSeq(seq2)) onError("Expected a sequence for this tag");
        return seq2;
    }
};
// ../../node_modules/yaml/browser/dist/schema/common/string.js
var string = {
    identify: (value1)=>typeof value1 === "string",
    default: true,
    tag: "tag:yaml.org,2002:str",
    resolve: (str)=>str,
    stringify (item, ctx, onComment, onChompKeep) {
        ctx = Object.assign({
            actualString: true
        }, ctx);
        return stringifyString(item, ctx, onComment, onChompKeep);
    }
};
// ../../node_modules/yaml/browser/dist/schema/common/null.js
var nullTag = {
    identify: (value1)=>value1 == null,
    createNode: ()=>new Scalar(null),
    default: true,
    tag: "tag:yaml.org,2002:null",
    test: /^(?:~|[Nn]ull|NULL)?$/,
    resolve: ()=>new Scalar(null),
    stringify: ({ source }, ctx)=>typeof source === "string" && nullTag.test.test(source) ? source : ctx.options.nullStr
};
// ../../node_modules/yaml/browser/dist/schema/core/bool.js
var boolTag = {
    identify: (value1)=>typeof value1 === "boolean",
    default: true,
    tag: "tag:yaml.org,2002:bool",
    test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
    resolve: (str)=>new Scalar(str[0] === "t" || str[0] === "T"),
    stringify ({ source, value: value1 }, ctx) {
        if (source && boolTag.test.test(source)) {
            const sv = source[0] === "t" || source[0] === "T";
            if (value1 === sv) return source;
        }
        return value1 ? ctx.options.trueStr : ctx.options.falseStr;
    }
};
// ../../node_modules/yaml/browser/dist/stringify/stringifyNumber.js
function stringifyNumber({ format: format5, minFractionDigits, tag, value: value1 }) {
    if (typeof value1 === "bigint") return String(value1);
    const num = typeof value1 === "number" ? value1 : Number(value1);
    if (!isFinite(num)) return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
    let n = JSON.stringify(value1);
    if (!format5 && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) {
        let i = n.indexOf(".");
        if (i < 0) {
            i = n.length;
            n += ".";
        }
        let d = minFractionDigits - (n.length - i - 1);
        while(d-- > 0)n += "0";
    }
    return n;
}
// ../../node_modules/yaml/browser/dist/schema/core/float.js
var floatNaN = {
    identify: (value1)=>typeof value1 === "number",
    default: true,
    tag: "tag:yaml.org,2002:float",
    test: /^(?:[-+]?\.(?:inf|Inf|INF|nan|NaN|NAN))$/,
    resolve: (str)=>str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
    stringify: stringifyNumber
};
var floatExp = {
    identify: (value1)=>typeof value1 === "number",
    default: true,
    tag: "tag:yaml.org,2002:float",
    format: "EXP",
    test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
    resolve: (str)=>parseFloat(str),
    stringify (node) {
        const num = Number(node.value);
        return isFinite(num) ? num.toExponential() : stringifyNumber(node);
    }
};
var lib_float = {
    identify: (value1)=>typeof value1 === "number",
    default: true,
    tag: "tag:yaml.org,2002:float",
    test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
    resolve (str) {
        const node = new Scalar(parseFloat(str));
        const dot = str.indexOf(".");
        if (dot !== -1 && str[str.length - 1] === "0") node.minFractionDigits = str.length - dot - 1;
        return node;
    },
    stringify: stringifyNumber
};
// ../../node_modules/yaml/browser/dist/schema/core/int.js
var intIdentify = (value1)=>typeof value1 === "bigint" || Number.isInteger(value1);
var intResolve = (str, offset, radix, { intAsBigInt })=>intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix);
function intStringify(node, radix, prefix) {
    const { value: value1 } = node;
    if (intIdentify(value1) && value1 >= 0) return prefix + value1.toString(radix);
    return stringifyNumber(node);
}
var intOct = {
    identify: (value1)=>intIdentify(value1) && value1 >= 0,
    default: true,
    tag: "tag:yaml.org,2002:int",
    format: "OCT",
    test: /^0o[0-7]+$/,
    resolve: (str, _onError, opt)=>intResolve(str, 2, 8, opt),
    stringify: (node)=>intStringify(node, 8, "0o")
};
var lib_int = {
    identify: intIdentify,
    default: true,
    tag: "tag:yaml.org,2002:int",
    test: /^[-+]?[0-9]+$/,
    resolve: (str, _onError, opt)=>intResolve(str, 0, 10, opt),
    stringify: stringifyNumber
};
var intHex = {
    identify: (value1)=>intIdentify(value1) && value1 >= 0,
    default: true,
    tag: "tag:yaml.org,2002:int",
    format: "HEX",
    test: /^0x[0-9a-fA-F]+$/,
    resolve: (str, _onError, opt)=>intResolve(str, 2, 16, opt),
    stringify: (node)=>intStringify(node, 16, "0x")
};
// ../../node_modules/yaml/browser/dist/schema/core/schema.js
var schema = [
    map,
    seq,
    string,
    nullTag,
    boolTag,
    intOct,
    lib_int,
    intHex,
    floatNaN,
    floatExp,
    lib_float
];
// ../../node_modules/yaml/browser/dist/schema/json/schema.js
function intIdentify2(value1) {
    return typeof value1 === "bigint" || Number.isInteger(value1);
}
var stringifyJSON = ({ value: value1 })=>JSON.stringify(value1);
var jsonScalars = [
    {
        identify: (value1)=>typeof value1 === "string",
        default: true,
        tag: "tag:yaml.org,2002:str",
        resolve: (str)=>str,
        stringify: stringifyJSON
    },
    {
        identify: (value1)=>value1 == null,
        createNode: ()=>new Scalar(null),
        default: true,
        tag: "tag:yaml.org,2002:null",
        test: /^null$/,
        resolve: ()=>null,
        stringify: stringifyJSON
    },
    {
        identify: (value1)=>typeof value1 === "boolean",
        default: true,
        tag: "tag:yaml.org,2002:bool",
        test: /^true|false$/,
        resolve: (str)=>str === "true",
        stringify: stringifyJSON
    },
    {
        identify: intIdentify2,
        default: true,
        tag: "tag:yaml.org,2002:int",
        test: /^-?(?:0|[1-9][0-9]*)$/,
        resolve: (str, _onError, { intAsBigInt })=>intAsBigInt ? BigInt(str) : parseInt(str, 10),
        stringify: ({ value: value1 })=>intIdentify2(value1) ? value1.toString() : JSON.stringify(value1)
    },
    {
        identify: (value1)=>typeof value1 === "number",
        default: true,
        tag: "tag:yaml.org,2002:float",
        test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
        resolve: (str)=>parseFloat(str),
        stringify: stringifyJSON
    }
];
var jsonError = {
    default: true,
    tag: "",
    test: /^/,
    resolve (str, onError) {
        onError(`Unresolved plain scalar ${JSON.stringify(str)}`);
        return str;
    }
};
var schema2 = [
    map,
    seq
].concat(jsonScalars, jsonError);
// ../../node_modules/yaml/browser/dist/schema/yaml-1.1/binary.js
var binary = {
    identify: (value1)=>value1 instanceof Uint8Array,
    default: false,
    tag: "tag:yaml.org,2002:binary",
    /**
   * Returns a Buffer in node and an Uint8Array in browsers
   *
   * To use the resulting buffer as an image, you'll want to do something like:
   *
   *   const blob = new Blob([buffer], { type: 'image/jpeg' })
   *   document.querySelector('#photo').src = URL.createObjectURL(blob)
   */ resolve (src, onError) {
        if (typeof Buffer === "function") {
            return Buffer.from(src, "base64");
        } else if (typeof atob === "function") {
            const str = atob(src.replace(/[\n\r]/g, ""));
            const buffer = new Uint8Array(str.length);
            for(let i = 0; i < str.length; ++i)buffer[i] = str.charCodeAt(i);
            return buffer;
        } else {
            onError("This environment does not support reading binary tags; either Buffer or atob is required");
            return src;
        }
    },
    stringify ({ comment, type, value: value1 }, ctx, onComment, onChompKeep) {
        const buf = value1;
        let str;
        if (typeof Buffer === "function") {
            str = buf instanceof Buffer ? buf.toString("base64") : Buffer.from(buf.buffer).toString("base64");
        } else if (typeof btoa === "function") {
            let s = "";
            for(let i = 0; i < buf.length; ++i)s += String.fromCharCode(buf[i]);
            str = btoa(s);
        } else {
            throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required");
        }
        if (!type) type = Scalar.BLOCK_LITERAL;
        if (type !== Scalar.QUOTE_DOUBLE) {
            const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
            const n = Math.ceil(str.length / lineWidth);
            const lines = new Array(n);
            for(let i = 0, o = 0; i < n; ++i, o += lineWidth){
                lines[i] = str.substr(o, lineWidth);
            }
            str = lines.join(type === Scalar.BLOCK_LITERAL ? "\n" : " ");
        }
        return stringifyString({
            comment,
            type,
            value: str
        }, ctx, onComment, onChompKeep);
    }
};
// ../../node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js
function resolvePairs(seq2, onError) {
    var _a;
    if (isSeq(seq2)) {
        for(let i = 0; i < seq2.items.length; ++i){
            let item = seq2.items[i];
            if (isPair(item)) continue;
            else if (isMap(item)) {
                if (item.items.length > 1) onError("Each pair must have its own sequence indicator");
                const pair = item.items[0] || new Pair(new Scalar(null));
                if (item.commentBefore) pair.key.commentBefore = pair.key.commentBefore ? `${item.commentBefore}
${pair.key.commentBefore}` : item.commentBefore;
                if (item.comment) {
                    const cn = (_a = pair.value) != null ? _a : pair.key;
                    cn.comment = cn.comment ? `${item.comment}
${cn.comment}` : item.comment;
                }
                item = pair;
            }
            seq2.items[i] = isPair(item) ? item : new Pair(item);
        }
    } else onError("Expected a sequence for this tag");
    return seq2;
}
function createPairs(schema4, iterable, ctx) {
    const { replacer } = ctx;
    const pairs2 = new YAMLSeq(schema4);
    pairs2.tag = "tag:yaml.org,2002:pairs";
    let i = 0;
    if (iterable && Symbol.iterator in Object(iterable)) for (let it of iterable){
        if (typeof replacer === "function") it = replacer.call(iterable, String(i++), it);
        let key, value1;
        if (Array.isArray(it)) {
            if (it.length === 2) {
                key = it[0];
                value1 = it[1];
            } else throw new TypeError(`Expected [key, value] tuple: ${it}`);
        } else if (it && it instanceof Object) {
            const keys = Object.keys(it);
            if (keys.length === 1) {
                key = keys[0];
                value1 = it[key];
            } else throw new TypeError(`Expected { key: value } tuple: ${it}`);
        } else {
            key = it;
        }
        pairs2.items.push(createPair(key, value1, ctx));
    }
    return pairs2;
}
var pairs = {
    collection: "seq",
    default: false,
    tag: "tag:yaml.org,2002:pairs",
    resolve: resolvePairs,
    createNode: createPairs
};
// ../../node_modules/yaml/browser/dist/schema/yaml-1.1/omap.js
var YAMLOMap = class _YAMLOMap extends YAMLSeq {
    /**
   * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
   * but TypeScript won't allow widening the signature of a child method.
   */ toJSON(_2, ctx) {
        if (!ctx) return super.toJSON(_2);
        const map2 = /* @__PURE__ */ new Map();
        if (ctx == null ? void 0 : ctx.onCreate) ctx.onCreate(map2);
        for (const pair of this.items){
            let key, value1;
            if (isPair(pair)) {
                key = toJS(pair.key, "", ctx);
                value1 = toJS(pair.value, key, ctx);
            } else {
                key = toJS(pair, "", ctx);
            }
            if (map2.has(key)) throw new Error("Ordered maps must not include duplicate keys");
            map2.set(key, value1);
        }
        return map2;
    }
    constructor(){
        super();
        this.add = YAMLMap.prototype.add.bind(this);
        this.delete = YAMLMap.prototype.delete.bind(this);
        this.get = YAMLMap.prototype.get.bind(this);
        this.has = YAMLMap.prototype.has.bind(this);
        this.set = YAMLMap.prototype.set.bind(this);
        this.tag = _YAMLOMap.tag;
    }
};
YAMLOMap.tag = "tag:yaml.org,2002:omap";
var omap = {
    collection: "seq",
    identify: (value1)=>value1 instanceof Map,
    nodeClass: YAMLOMap,
    default: false,
    tag: "tag:yaml.org,2002:omap",
    resolve (seq2, onError) {
        const pairs2 = resolvePairs(seq2, onError);
        const seenKeys = [];
        for (const { key } of pairs2.items){
            if (isScalar(key)) {
                if (seenKeys.includes(key.value)) {
                    onError(`Ordered maps must not include duplicate keys: ${key.value}`);
                } else {
                    seenKeys.push(key.value);
                }
            }
        }
        return Object.assign(new YAMLOMap(), pairs2);
    },
    createNode (schema4, iterable, ctx) {
        const pairs2 = createPairs(schema4, iterable, ctx);
        const omap2 = new YAMLOMap();
        omap2.items = pairs2.items;
        return omap2;
    }
};
// ../../node_modules/yaml/browser/dist/schema/yaml-1.1/bool.js
function boolStringify({ value: value1, source }, ctx) {
    const boolObj = value1 ? trueTag : falseTag;
    if (source && boolObj.test.test(source)) return source;
    return value1 ? ctx.options.trueStr : ctx.options.falseStr;
}
var trueTag = {
    identify: (value1)=>value1 === true,
    default: true,
    tag: "tag:yaml.org,2002:bool",
    test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
    resolve: ()=>new Scalar(true),
    stringify: boolStringify
};
var falseTag = {
    identify: (value1)=>value1 === false,
    default: true,
    tag: "tag:yaml.org,2002:bool",
    test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,
    resolve: ()=>new Scalar(false),
    stringify: boolStringify
};
// ../../node_modules/yaml/browser/dist/schema/yaml-1.1/float.js
var floatNaN2 = {
    identify: (value1)=>typeof value1 === "number",
    default: true,
    tag: "tag:yaml.org,2002:float",
    test: /^[-+]?\.(?:inf|Inf|INF|nan|NaN|NAN)$/,
    resolve: (str)=>str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
    stringify: stringifyNumber
};
var floatExp2 = {
    identify: (value1)=>typeof value1 === "number",
    default: true,
    tag: "tag:yaml.org,2002:float",
    format: "EXP",
    test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
    resolve: (str)=>parseFloat(str.replace(/_/g, "")),
    stringify (node) {
        const num = Number(node.value);
        return isFinite(num) ? num.toExponential() : stringifyNumber(node);
    }
};
var float2 = {
    identify: (value1)=>typeof value1 === "number",
    default: true,
    tag: "tag:yaml.org,2002:float",
    test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
    resolve (str) {
        const node = new Scalar(parseFloat(str.replace(/_/g, "")));
        const dot = str.indexOf(".");
        if (dot !== -1) {
            const f2 = str.substring(dot + 1).replace(/_/g, "");
            if (f2[f2.length - 1] === "0") node.minFractionDigits = f2.length;
        }
        return node;
    },
    stringify: stringifyNumber
};
// ../../node_modules/yaml/browser/dist/schema/yaml-1.1/int.js
var intIdentify3 = (value1)=>typeof value1 === "bigint" || Number.isInteger(value1);
function intResolve2(str, offset, radix, { intAsBigInt }) {
    const sign = str[0];
    if (sign === "-" || sign === "+") offset += 1;
    str = str.substring(offset).replace(/_/g, "");
    if (intAsBigInt) {
        switch(radix){
            case 2:
                str = `0b${str}`;
                break;
            case 8:
                str = `0o${str}`;
                break;
            case 16:
                str = `0x${str}`;
                break;
        }
        const n2 = BigInt(str);
        return sign === "-" ? BigInt(-1) * n2 : n2;
    }
    const n = parseInt(str, radix);
    return sign === "-" ? -1 * n : n;
}
function intStringify2(node, radix, prefix) {
    const { value: value1 } = node;
    if (intIdentify3(value1)) {
        const str = value1.toString(radix);
        return value1 < 0 ? "-" + prefix + str.substr(1) : prefix + str;
    }
    return stringifyNumber(node);
}
var intBin = {
    identify: intIdentify3,
    default: true,
    tag: "tag:yaml.org,2002:int",
    format: "BIN",
    test: /^[-+]?0b[0-1_]+$/,
    resolve: (str, _onError, opt)=>intResolve2(str, 2, 2, opt),
    stringify: (node)=>intStringify2(node, 2, "0b")
};
var intOct2 = {
    identify: intIdentify3,
    default: true,
    tag: "tag:yaml.org,2002:int",
    format: "OCT",
    test: /^[-+]?0[0-7_]+$/,
    resolve: (str, _onError, opt)=>intResolve2(str, 1, 8, opt),
    stringify: (node)=>intStringify2(node, 8, "0")
};
var int2 = {
    identify: intIdentify3,
    default: true,
    tag: "tag:yaml.org,2002:int",
    test: /^[-+]?[0-9][0-9_]*$/,
    resolve: (str, _onError, opt)=>intResolve2(str, 0, 10, opt),
    stringify: stringifyNumber
};
var intHex2 = {
    identify: intIdentify3,
    default: true,
    tag: "tag:yaml.org,2002:int",
    format: "HEX",
    test: /^[-+]?0x[0-9a-fA-F_]+$/,
    resolve: (str, _onError, opt)=>intResolve2(str, 2, 16, opt),
    stringify: (node)=>intStringify2(node, 16, "0x")
};
// ../../node_modules/yaml/browser/dist/schema/yaml-1.1/set.js
var YAMLSet = class _YAMLSet extends YAMLMap {
    add(key) {
        let pair;
        if (isPair(key)) pair = key;
        else if (key && typeof key === "object" && "key" in key && "value" in key && key.value === null) pair = new Pair(key.key, null);
        else pair = new Pair(key, null);
        const prev = findPair(this.items, pair.key);
        if (!prev) this.items.push(pair);
    }
    /**
   * If `keepPair` is `true`, returns the Pair matching `key`.
   * Otherwise, returns the value of that Pair's key.
   */ get(key, keepPair) {
        const pair = findPair(this.items, key);
        return !keepPair && isPair(pair) ? isScalar(pair.key) ? pair.key.value : pair.key : pair;
    }
    set(key, value1) {
        if (typeof value1 !== "boolean") throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value1}`);
        const prev = findPair(this.items, key);
        if (prev && !value1) {
            this.items.splice(this.items.indexOf(prev), 1);
        } else if (!prev && value1) {
            this.items.push(new Pair(key));
        }
    }
    toJSON(_2, ctx) {
        return super.toJSON(_2, ctx, Set);
    }
    toString(ctx, onComment, onChompKeep) {
        if (!ctx) return JSON.stringify(this);
        if (this.hasAllNullValues(true)) return super.toString(Object.assign({}, ctx, {
            allNullValues: true
        }), onComment, onChompKeep);
        else throw new Error("Set items must all have null values");
    }
    constructor(schema4){
        super(schema4);
        this.tag = _YAMLSet.tag;
    }
};
YAMLSet.tag = "tag:yaml.org,2002:set";
var set = {
    collection: "map",
    identify: (value1)=>value1 instanceof Set,
    nodeClass: YAMLSet,
    default: false,
    tag: "tag:yaml.org,2002:set",
    resolve (map2, onError) {
        if (isMap(map2)) {
            if (map2.hasAllNullValues(true)) return Object.assign(new YAMLSet(), map2);
            else onError("Set items must all have null values");
        } else onError("Expected a mapping for this tag");
        return map2;
    },
    createNode (schema4, iterable, ctx) {
        const { replacer } = ctx;
        const set2 = new YAMLSet(schema4);
        if (iterable && Symbol.iterator in Object(iterable)) for (let value1 of iterable){
            if (typeof replacer === "function") value1 = replacer.call(iterable, value1, value1);
            set2.items.push(createPair(value1, null, ctx));
        }
        return set2;
    }
};
// ../../node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.js
function parseSexagesimal(str, asBigInt) {
    const sign = str[0];
    const parts = sign === "-" || sign === "+" ? str.substring(1) : str;
    const num = (n)=>asBigInt ? BigInt(n) : Number(n);
    const res = parts.replace(/_/g, "").split(":").reduce((res2, p)=>res2 * num(60) + num(p), num(0));
    return sign === "-" ? num(-1) * res : res;
}
function stringifySexagesimal(node) {
    let { value: value1 } = node;
    let num = (n)=>n;
    if (typeof value1 === "bigint") num = (n)=>BigInt(n);
    else if (isNaN(value1) || !isFinite(value1)) return stringifyNumber(node);
    let sign = "";
    if (value1 < 0) {
        sign = "-";
        value1 *= num(-1);
    }
    const _60 = num(60);
    const parts = [
        value1 % _60
    ];
    if (value1 < 60) {
        parts.unshift(0);
    } else {
        value1 = (value1 - parts[0]) / _60;
        parts.unshift(value1 % _60);
        if (value1 >= 60) {
            value1 = (value1 - parts[0]) / _60;
            parts.unshift(value1);
        }
    }
    return sign + parts.map((n)=>n < 10 ? "0" + String(n) : String(n)).join(":").replace(/000000\d*$/, "");
}
var intTime = {
    identify: (value1)=>typeof value1 === "bigint" || Number.isInteger(value1),
    default: true,
    tag: "tag:yaml.org,2002:int",
    format: "TIME",
    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
    resolve: (str, _onError, { intAsBigInt })=>parseSexagesimal(str, intAsBigInt),
    stringify: stringifySexagesimal
};
var floatTime = {
    identify: (value1)=>typeof value1 === "number",
    default: true,
    tag: "tag:yaml.org,2002:float",
    format: "TIME",
    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
    resolve: (str)=>parseSexagesimal(str, false),
    stringify: stringifySexagesimal
};
var timestamp = {
    identify: (value1)=>value1 instanceof Date,
    default: true,
    tag: "tag:yaml.org,2002:timestamp",
    // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part
    // may be omitted altogether, resulting in a date format. In such a case, the time part is
    // assumed to be 00:00:00Z (start of day, UTC).
    test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?$"),
    resolve (str) {
        const match = str.match(timestamp.test);
        if (!match) throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
        const [, year, month, day, hour, minute, second] = match.map(Number);
        const millisec = match[7] ? Number((match[7] + "00").substr(1, 3)) : 0;
        let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);
        const tz = match[8];
        if (tz && tz !== "Z") {
            let d = parseSexagesimal(tz, false);
            if (Math.abs(d) < 30) d *= 60;
            date -= 6e4 * d;
        }
        return new Date(date);
    },
    stringify: ({ value: value1 })=>value1.toISOString().replace(/((T00:00)?:00)?\.000Z$/, "")
};
// ../../node_modules/yaml/browser/dist/schema/yaml-1.1/schema.js
var schema3 = [
    map,
    seq,
    string,
    nullTag,
    trueTag,
    falseTag,
    intBin,
    intOct2,
    int2,
    intHex2,
    floatNaN2,
    floatExp2,
    float2,
    binary,
    omap,
    pairs,
    set,
    intTime,
    floatTime,
    timestamp
];
// ../../node_modules/yaml/browser/dist/schema/tags.js
var schemas = /* @__PURE__ */ new Map([
    [
        "core",
        schema
    ],
    [
        "failsafe",
        [
            map,
            seq,
            string
        ]
    ],
    [
        "json",
        schema2
    ],
    [
        "yaml11",
        schema3
    ],
    [
        "yaml-1.1",
        schema3
    ]
]);
var tagsByName = {
    binary,
    bool: boolTag,
    float: lib_float,
    floatExp,
    floatNaN,
    floatTime,
    int: lib_int,
    intHex,
    intOct,
    intTime,
    map,
    null: nullTag,
    omap,
    pairs,
    seq,
    set,
    timestamp
};
var coreKnownTags = {
    "tag:yaml.org,2002:binary": binary,
    "tag:yaml.org,2002:omap": omap,
    "tag:yaml.org,2002:pairs": pairs,
    "tag:yaml.org,2002:set": set,
    "tag:yaml.org,2002:timestamp": timestamp
};
function getTags(customTags, schemaName) {
    let tags = schemas.get(schemaName);
    if (!tags) {
        if (Array.isArray(customTags)) tags = [];
        else {
            const keys = Array.from(schemas.keys()).filter((key)=>key !== "yaml11").map((key)=>JSON.stringify(key)).join(", ");
            throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
        }
    }
    if (Array.isArray(customTags)) {
        for (const tag of customTags)tags = tags.concat(tag);
    } else if (typeof customTags === "function") {
        tags = customTags(tags.slice());
    }
    return tags.map((tag)=>{
        if (typeof tag !== "string") return tag;
        const tagObj = tagsByName[tag];
        if (tagObj) return tagObj;
        const keys = Object.keys(tagsByName).map((key)=>JSON.stringify(key)).join(", ");
        throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
    });
}
// ../../node_modules/yaml/browser/dist/schema/Schema.js
var sortMapEntriesByKey = (a2, b)=>a2.key < b.key ? -1 : a2.key > b.key ? 1 : 0;
var Schema = class _Schema {
    clone() {
        const copy = Object.create(_Schema.prototype, Object.getOwnPropertyDescriptors(this));
        copy.tags = this.tags.slice();
        return copy;
    }
    constructor({ compat, customTags, merge, resolveKnownTags, schema: schema4, sortMapEntries, toStringDefaults }){
        this.compat = Array.isArray(compat) ? getTags(compat, "compat") : compat ? getTags(null, compat) : null;
        this.merge = !!merge;
        this.name = typeof schema4 === "string" && schema4 || "core";
        this.knownTags = resolveKnownTags ? coreKnownTags : {};
        this.tags = getTags(customTags, this.name);
        this.toStringOptions = toStringDefaults != null ? toStringDefaults : null;
        Object.defineProperty(this, MAP, {
            value: map
        });
        Object.defineProperty(this, SCALAR, {
            value: string
        });
        Object.defineProperty(this, SEQ, {
            value: seq
        });
        this.sortMapEntries = typeof sortMapEntries === "function" ? sortMapEntries : sortMapEntries === true ? sortMapEntriesByKey : null;
    }
};
// ../../node_modules/yaml/browser/dist/stringify/stringifyDocument.js
function stringifyDocument(doc, options) {
    var _a;
    const lines = [];
    let hasDirectives = options.directives === true;
    if (options.directives !== false && doc.directives) {
        const dir = doc.directives.toString(doc);
        if (dir) {
            lines.push(dir);
            hasDirectives = true;
        } else if (doc.directives.docStart) hasDirectives = true;
    }
    if (hasDirectives) lines.push("---");
    const ctx = createStringifyContext(doc, options);
    const { commentString } = ctx.options;
    if (doc.commentBefore) {
        if (lines.length !== 1) lines.unshift("");
        const cs = commentString(doc.commentBefore);
        lines.unshift(indentComment(cs, ""));
    }
    let chompKeep = false;
    let contentComment = null;
    if (doc.contents) {
        if (isNode(doc.contents)) {
            if (doc.contents.spaceBefore && hasDirectives) lines.push("");
            if (doc.contents.commentBefore) {
                const cs = commentString(doc.contents.commentBefore);
                lines.push(indentComment(cs, ""));
            }
            ctx.forceBlockIndent = !!doc.comment;
            contentComment = doc.contents.comment;
        }
        const onChompKeep = contentComment ? void 0 : ()=>chompKeep = true;
        let body = stringify(doc.contents, ctx, ()=>contentComment = null, onChompKeep);
        if (contentComment) body += lineComment(body, "", commentString(contentComment));
        if ((body[0] === "|" || body[0] === ">") && lines[lines.length - 1] === "---") {
            lines[lines.length - 1] = `--- ${body}`;
        } else lines.push(body);
    } else {
        lines.push(stringify(doc.contents, ctx));
    }
    if ((_a = doc.directives) == null ? void 0 : _a.docEnd) {
        if (doc.comment) {
            const cs = commentString(doc.comment);
            if (cs.includes("\n")) {
                lines.push("...");
                lines.push(indentComment(cs, ""));
            } else {
                lines.push(`... ${cs}`);
            }
        } else {
            lines.push("...");
        }
    } else {
        let dc = doc.comment;
        if (dc && chompKeep) dc = dc.replace(/^\n+/, "");
        if (dc) {
            if ((!chompKeep || contentComment) && lines[lines.length - 1] !== "") lines.push("");
            lines.push(indentComment(commentString(dc), ""));
        }
    }
    return lines.join("\n") + "\n";
}
// ../../node_modules/yaml/browser/dist/doc/applyReviver.js
function applyReviver(reviver, obj, key, val) {
    if (val && typeof val === "object") {
        if (Array.isArray(val)) {
            for(let i = 0, len = val.length; i < len; ++i){
                const v0 = val[i];
                const v1 = applyReviver(reviver, val, String(i), v0);
                if (v1 === void 0) delete val[i];
                else if (v1 !== v0) val[i] = v1;
            }
        } else if (val instanceof Map) {
            for (const k of Array.from(val.keys())){
                const v0 = val.get(k);
                const v1 = applyReviver(reviver, val, k, v0);
                if (v1 === void 0) val.delete(k);
                else if (v1 !== v0) val.set(k, v1);
            }
        } else if (val instanceof Set) {
            for (const v0 of Array.from(val)){
                const v1 = applyReviver(reviver, val, v0, v0);
                if (v1 === void 0) val.delete(v0);
                else if (v1 !== v0) {
                    val.delete(v0);
                    val.add(v1);
                }
            }
        } else {
            for (const [k, v0] of Object.entries(val)){
                const v1 = applyReviver(reviver, val, k, v0);
                if (v1 === void 0) delete val[k];
                else if (v1 !== v0) val[k] = v1;
            }
        }
    }
    return reviver.call(obj, key, val);
}
// ../../node_modules/yaml/browser/dist/doc/Document.js
var Document = class _Document {
    /**
   * Create a deep copy of this Document and its contents.
   *
   * Custom Node values that inherit from `Object` still refer to their original instances.
   */ clone() {
        const copy = Object.create(_Document.prototype, {
            [NODE_TYPE]: {
                value: DOC
            }
        });
        copy.commentBefore = this.commentBefore;
        copy.comment = this.comment;
        copy.errors = this.errors.slice();
        copy.warnings = this.warnings.slice();
        copy.options = Object.assign({}, this.options);
        if (this.directives) copy.directives = this.directives.clone();
        copy.schema = this.schema.clone();
        copy.contents = isNode(this.contents) ? this.contents.clone(copy.schema) : this.contents;
        if (this.range) copy.range = this.range.slice();
        return copy;
    }
    /** Adds a value to the document. */ add(value1) {
        if (assertCollection(this.contents)) this.contents.add(value1);
    }
    /** Adds a value to the document. */ addIn(path5, value1) {
        if (assertCollection(this.contents)) this.contents.addIn(path5, value1);
    }
    /**
   * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
   *
   * If `node` already has an anchor, `name` is ignored.
   * Otherwise, the `node.anchor` value will be set to `name`,
   * or if an anchor with that name is already present in the document,
   * `name` will be used as a prefix for a new unique anchor.
   * If `name` is undefined, the generated anchor will use 'a' as a prefix.
   */ createAlias(node, name) {
        if (!node.anchor) {
            const prev = anchorNames(this);
            node.anchor = !name || prev.has(name) ? findNewAnchor(name || "a", prev) : name;
        }
        return new Alias(node.anchor);
    }
    createNode(value1, replacer, options) {
        let _replacer = void 0;
        if (typeof replacer === "function") {
            value1 = replacer.call({
                "": value1
            }, "", value1);
            _replacer = replacer;
        } else if (Array.isArray(replacer)) {
            const keyToStr = (v)=>typeof v === "number" || v instanceof String || v instanceof Number;
            const asStr = replacer.filter(keyToStr).map(String);
            if (asStr.length > 0) replacer = replacer.concat(asStr);
            _replacer = replacer;
        } else if (options === void 0 && replacer) {
            options = replacer;
            replacer = void 0;
        }
        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options != null ? options : {};
        const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
        anchorPrefix || "a");
        const ctx = {
            aliasDuplicateObjects: aliasDuplicateObjects != null ? aliasDuplicateObjects : true,
            keepUndefined: keepUndefined != null ? keepUndefined : false,
            onAnchor,
            onTagObj,
            replacer: _replacer,
            schema: this.schema,
            sourceObjects
        };
        const node = createNode(value1, tag, ctx);
        if (flow && isCollection(node)) node.flow = true;
        setAnchors();
        return node;
    }
    /**
   * Convert a key and a value into a `Pair` using the current schema,
   * recursively wrapping all values as `Scalar` or `Collection` nodes.
   */ createPair(key, value1, options = {}) {
        const k = this.createNode(key, null, options);
        const v = this.createNode(value1, null, options);
        return new Pair(k, v);
    }
    /**
   * Removes a value from the document.
   * @returns `true` if the item was found and removed.
   */ delete(key) {
        return assertCollection(this.contents) ? this.contents.delete(key) : false;
    }
    /**
   * Removes a value from the document.
   * @returns `true` if the item was found and removed.
   */ deleteIn(path5) {
        if (isEmptyPath(path5)) {
            if (this.contents == null) return false;
            this.contents = null;
            return true;
        }
        return assertCollection(this.contents) ? this.contents.deleteIn(path5) : false;
    }
    /**
   * Returns item at `key`, or `undefined` if not found. By default unwraps
   * scalar values from their surrounding node; to disable set `keepScalar` to
   * `true` (collections are always returned intact).
   */ get(key, keepScalar) {
        return isCollection(this.contents) ? this.contents.get(key, keepScalar) : void 0;
    }
    /**
   * Returns item at `path`, or `undefined` if not found. By default unwraps
   * scalar values from their surrounding node; to disable set `keepScalar` to
   * `true` (collections are always returned intact).
   */ getIn(path5, keepScalar) {
        if (isEmptyPath(path5)) return !keepScalar && isScalar(this.contents) ? this.contents.value : this.contents;
        return isCollection(this.contents) ? this.contents.getIn(path5, keepScalar) : void 0;
    }
    /**
   * Checks if the document includes a value with the key `key`.
   */ has(key) {
        return isCollection(this.contents) ? this.contents.has(key) : false;
    }
    /**
   * Checks if the document includes a value at `path`.
   */ hasIn(path5) {
        if (isEmptyPath(path5)) return this.contents !== void 0;
        return isCollection(this.contents) ? this.contents.hasIn(path5) : false;
    }
    /**
   * Sets a value in this document. For `!!set`, `value` needs to be a
   * boolean to add/remove the item from the set.
   */ set(key, value1) {
        if (this.contents == null) {
            this.contents = collectionFromPath(this.schema, [
                key
            ], value1);
        } else if (assertCollection(this.contents)) {
            this.contents.set(key, value1);
        }
    }
    /**
   * Sets a value in this document. For `!!set`, `value` needs to be a
   * boolean to add/remove the item from the set.
   */ setIn(path5, value1) {
        if (isEmptyPath(path5)) this.contents = value1;
        else if (this.contents == null) {
            this.contents = collectionFromPath(this.schema, Array.from(path5), value1);
        } else if (assertCollection(this.contents)) {
            this.contents.setIn(path5, value1);
        }
    }
    /**
   * Change the YAML version and schema used by the document.
   * A `null` version disables support for directives, explicit tags, anchors, and aliases.
   * It also requires the `schema` option to be given as a `Schema` instance value.
   *
   * Overrides all previously set schema options.
   */ setSchema(version, options = {}) {
        if (typeof version === "number") version = String(version);
        let opt;
        switch(version){
            case "1.1":
                if (this.directives) this.directives.yaml.version = "1.1";
                else this.directives = new Directives({
                    version: "1.1"
                });
                opt = {
                    merge: true,
                    resolveKnownTags: false,
                    schema: "yaml-1.1"
                };
                break;
            case "1.2":
            case "next":
                if (this.directives) this.directives.yaml.version = version;
                else this.directives = new Directives({
                    version
                });
                opt = {
                    merge: false,
                    resolveKnownTags: true,
                    schema: "core"
                };
                break;
            case null:
                if (this.directives) delete this.directives;
                opt = null;
                break;
            default:
                {
                    const sv = JSON.stringify(version);
                    throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`);
                }
        }
        if (options.schema instanceof Object) this.schema = options.schema;
        else if (opt) this.schema = new Schema(Object.assign(opt, options));
        else throw new Error(`With a null YAML version, the { schema: Schema } option is required`);
    }
    // json & jsonArg are only used from toJSON()
    toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
        const ctx = {
            anchors: /* @__PURE__ */ new Map(),
            doc: this,
            keep: !json,
            mapAsMap: mapAsMap === true,
            mapKeyWarned: false,
            maxAliasCount: typeof maxAliasCount === "number" ? maxAliasCount : 100,
            stringify
        };
        const res = toJS(this.contents, jsonArg != null ? jsonArg : "", ctx);
        if (typeof onAnchor === "function") for (const { count, res: res2 } of ctx.anchors.values())onAnchor(res2, count);
        return typeof reviver === "function" ? applyReviver(reviver, {
            "": res
        }, "", res) : res;
    }
    /**
   * A JSON representation of the document `contents`.
   *
   * @param jsonArg Used by `JSON.stringify` to indicate the array index or
   *   property name.
   */ toJSON(jsonArg, onAnchor) {
        return this.toJS({
            json: true,
            jsonArg,
            mapAsMap: false,
            onAnchor
        });
    }
    /** A YAML representation of the document. */ toString(options = {}) {
        if (this.errors.length > 0) throw new Error("Document with errors cannot be stringified");
        if ("indent" in options && (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) {
            const s = JSON.stringify(options.indent);
            throw new Error(`"indent" option must be a positive integer, not ${s}`);
        }
        return stringifyDocument(this, options);
    }
    constructor(value1, replacer, options){
        this.commentBefore = null;
        this.comment = null;
        this.errors = [];
        this.warnings = [];
        Object.defineProperty(this, NODE_TYPE, {
            value: DOC
        });
        let _replacer = null;
        if (typeof replacer === "function" || Array.isArray(replacer)) {
            _replacer = replacer;
        } else if (options === void 0 && replacer) {
            options = replacer;
            replacer = void 0;
        }
        const opt = Object.assign({
            intAsBigInt: false,
            keepSourceTokens: false,
            logLevel: "warn",
            prettyErrors: true,
            strict: true,
            uniqueKeys: true,
            version: "1.2"
        }, options);
        this.options = opt;
        let { version } = opt;
        if (options == null ? void 0 : options._directives) {
            this.directives = options._directives.atDocument();
            if (this.directives.yaml.explicit) version = this.directives.yaml.version;
        } else this.directives = new Directives({
            version
        });
        this.setSchema(version, options);
        if (value1 === void 0) this.contents = null;
        else {
            this.contents = this.createNode(value1, _replacer, options);
        }
    }
};
function assertCollection(contents) {
    if (isCollection(contents)) return true;
    throw new Error("Expected a YAML collection as document contents");
}
// ../../node_modules/yaml/browser/dist/errors.js
var YAMLError = class extends Error {
    constructor(name, pos, code, message){
        super();
        this.name = name;
        this.code = code;
        this.message = message;
        this.pos = pos;
    }
};
var YAMLParseError = class extends YAMLError {
    constructor(pos, code, message){
        super("YAMLParseError", pos, code, message);
    }
};
var YAMLWarning = class extends YAMLError {
    constructor(pos, code, message){
        super("YAMLWarning", pos, code, message);
    }
};
var prettifyError = (src, lc)=>(error)=>{
        if (error.pos[0] === -1) return;
        error.linePos = error.pos.map((pos)=>lc.linePos(pos));
        const { line, col } = error.linePos[0];
        error.message += ` at line ${line}, column ${col}`;
        let ci = col - 1;
        let lineStr = src.substring(lc.lineStarts[line - 1], lc.lineStarts[line]).replace(/[\n\r]+$/, "");
        if (ci >= 60 && lineStr.length > 80) {
            const trimStart = Math.min(ci - 39, lineStr.length - 79);
            lineStr = "\u2026" + lineStr.substring(trimStart);
            ci -= trimStart - 1;
        }
        if (lineStr.length > 80) lineStr = lineStr.substring(0, 79) + "\u2026";
        if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
            let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
            if (prev.length > 80) prev = prev.substring(0, 79) + "\u2026\n";
            lineStr = prev + lineStr;
        }
        if (/[^ ]/.test(lineStr)) {
            let count = 1;
            const end = error.linePos[1];
            if (end && end.line === line && end.col > col) {
                count = Math.max(1, Math.min(end.col - col, 80 - ci));
            }
            const pointer = " ".repeat(ci) + "^".repeat(count);
            error.message += `:

${lineStr}
${pointer}
`;
        }
    };
// ../../node_modules/yaml/browser/dist/compose/resolve-props.js
function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnNewline }) {
    let spaceBefore = false;
    let atNewline = startOnNewline;
    let hasSpace = startOnNewline;
    let comment = "";
    let commentSep = "";
    let hasNewline = false;
    let hasNewlineAfterProp = false;
    let reqSpace = false;
    let anchor = null;
    let tag = null;
    let comma = null;
    let found = null;
    let start = null;
    for (const token of tokens){
        if (reqSpace) {
            if (token.type !== "space" && token.type !== "newline" && token.type !== "comma") onError(token.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
            reqSpace = false;
        }
        switch(token.type){
            case "space":
                if (!flow && atNewline && indicator !== "doc-start" && token.source[0] === "	") onError(token, "TAB_AS_INDENT", "Tabs are not allowed as indentation");
                hasSpace = true;
                break;
            case "comment":
                {
                    if (!hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
                    const cb = token.source.substring(1) || " ";
                    if (!comment) comment = cb;
                    else comment += commentSep + cb;
                    commentSep = "";
                    atNewline = false;
                    break;
                }
            case "newline":
                if (atNewline) {
                    if (comment) comment += token.source;
                    else spaceBefore = true;
                } else commentSep += token.source;
                atNewline = true;
                hasNewline = true;
                if (anchor || tag) hasNewlineAfterProp = true;
                hasSpace = true;
                break;
            case "anchor":
                if (anchor) onError(token, "MULTIPLE_ANCHORS", "A node can have at most one anchor");
                if (token.source.endsWith(":")) onError(token.offset + token.source.length - 1, "BAD_ALIAS", "Anchor ending in : is ambiguous", true);
                anchor = token;
                if (start === null) start = token.offset;
                atNewline = false;
                hasSpace = false;
                reqSpace = true;
                break;
            case "tag":
                {
                    if (tag) onError(token, "MULTIPLE_TAGS", "A node can have at most one tag");
                    tag = token;
                    if (start === null) start = token.offset;
                    atNewline = false;
                    hasSpace = false;
                    reqSpace = true;
                    break;
                }
            case indicator:
                if (anchor || tag) onError(token, "BAD_PROP_ORDER", `Anchors and tags must be after the ${token.source} indicator`);
                if (found) onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.source} in ${flow != null ? flow : "collection"}`);
                found = token;
                atNewline = false;
                hasSpace = false;
                break;
            case "comma":
                if (flow) {
                    if (comma) onError(token, "UNEXPECTED_TOKEN", `Unexpected , in ${flow}`);
                    comma = token;
                    atNewline = false;
                    hasSpace = false;
                    break;
                }
            default:
                onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.type} token`);
                atNewline = false;
                hasSpace = false;
        }
    }
    const last = tokens[tokens.length - 1];
    const end = last ? last.offset + last.source.length : offset;
    if (reqSpace && next && next.type !== "space" && next.type !== "newline" && next.type !== "comma" && (next.type !== "scalar" || next.source !== "")) onError(next.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
    return {
        comma,
        found,
        spaceBefore,
        comment,
        hasNewline,
        hasNewlineAfterProp,
        anchor,
        tag,
        end,
        start: start != null ? start : end
    };
}
// ../../node_modules/yaml/browser/dist/compose/util-contains-newline.js
function containsNewline(key) {
    if (!key) return null;
    switch(key.type){
        case "alias":
        case "scalar":
        case "double-quoted-scalar":
        case "single-quoted-scalar":
            if (key.source.includes("\n")) return true;
            if (key.end) {
                for (const st of key.end)if (st.type === "newline") return true;
            }
            return false;
        case "flow-collection":
            for (const it of key.items){
                for (const st of it.start)if (st.type === "newline") return true;
                if (it.sep) {
                    for (const st of it.sep)if (st.type === "newline") return true;
                }
                if (containsNewline(it.key) || containsNewline(it.value)) return true;
            }
            return false;
        default:
            return true;
    }
}
// ../../node_modules/yaml/browser/dist/compose/util-flow-indent-check.js
function flowIndentCheck(indent, fc, onError) {
    if ((fc == null ? void 0 : fc.type) === "flow-collection") {
        const end = fc.end[0];
        if (end.indent === indent && (end.source === "]" || end.source === "}") && containsNewline(fc)) {
            const msg = "Flow end indicator should be more indented than parent";
            onError(end, "BAD_INDENT", msg, true);
        }
    }
}
// ../../node_modules/yaml/browser/dist/compose/util-map-includes.js
function mapIncludes(ctx, items, search) {
    const { uniqueKeys } = ctx.options;
    if (uniqueKeys === false) return false;
    const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a2, b)=>a2 === b || isScalar(a2) && isScalar(b) && a2.value === b.value && !(a2.value === "<<" && ctx.schema.merge);
    return items.some((pair)=>isEqual(pair.key, search));
}
// ../../node_modules/yaml/browser/dist/compose/resolve-block-map.js
var startColMsg = "All mapping items must start at the same column";
function resolveBlockMap({ composeNode: composeNode2, composeEmptyNode: composeEmptyNode2 }, ctx, bm, onError) {
    var _a;
    const map2 = new YAMLMap(ctx.schema);
    if (ctx.atRoot) ctx.atRoot = false;
    let offset = bm.offset;
    let commentEnd = null;
    for (const collItem of bm.items){
        const { start, key, sep, value: value1 } = collItem;
        const keyProps = resolveProps(start, {
            indicator: "explicit-key-ind",
            next: key != null ? key : sep == null ? void 0 : sep[0],
            offset,
            onError,
            startOnNewline: true
        });
        const implicitKey = !keyProps.found;
        if (implicitKey) {
            if (key) {
                if (key.type === "block-seq") onError(offset, "BLOCK_AS_IMPLICIT_KEY", "A block sequence may not be used as an implicit map key");
                else if ("indent" in key && key.indent !== bm.indent) onError(offset, "BAD_INDENT", startColMsg);
            }
            if (!keyProps.anchor && !keyProps.tag && !sep) {
                commentEnd = keyProps.end;
                if (keyProps.comment) {
                    if (map2.comment) map2.comment += "\n" + keyProps.comment;
                    else map2.comment = keyProps.comment;
                }
                continue;
            }
            if (keyProps.hasNewlineAfterProp || containsNewline(key)) {
                onError(key != null ? key : start[start.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line");
            }
        } else if (((_a = keyProps.found) == null ? void 0 : _a.indent) !== bm.indent) {
            onError(offset, "BAD_INDENT", startColMsg);
        }
        const keyStart = keyProps.end;
        const keyNode = key ? composeNode2(ctx, key, keyProps, onError) : composeEmptyNode2(ctx, keyStart, start, null, keyProps, onError);
        if (ctx.schema.compat) flowIndentCheck(bm.indent, key, onError);
        if (mapIncludes(ctx, map2.items, keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
        const valueProps = resolveProps(sep != null ? sep : [], {
            indicator: "map-value-ind",
            next: value1,
            offset: keyNode.range[2],
            onError,
            startOnNewline: !key || key.type === "block-scalar"
        });
        offset = valueProps.end;
        if (valueProps.found) {
            if (implicitKey) {
                if ((value1 == null ? void 0 : value1.type) === "block-map" && !valueProps.hasNewline) onError(offset, "BLOCK_AS_IMPLICIT_KEY", "Nested mappings are not allowed in compact mappings");
                if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024) onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
            }
            const valueNode = value1 ? composeNode2(ctx, value1, valueProps, onError) : composeEmptyNode2(ctx, offset, sep, null, valueProps, onError);
            if (ctx.schema.compat) flowIndentCheck(bm.indent, value1, onError);
            offset = valueNode.range[2];
            const pair = new Pair(keyNode, valueNode);
            if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
            map2.items.push(pair);
        } else {
            if (implicitKey) onError(keyNode.range, "MISSING_CHAR", "Implicit map keys need to be followed by map values");
            if (valueProps.comment) {
                if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
                else keyNode.comment = valueProps.comment;
            }
            const pair = new Pair(keyNode);
            if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
            map2.items.push(pair);
        }
    }
    if (commentEnd && commentEnd < offset) onError(commentEnd, "IMPOSSIBLE", "Map comment with trailing content");
    map2.range = [
        bm.offset,
        offset,
        commentEnd != null ? commentEnd : offset
    ];
    return map2;
}
// ../../node_modules/yaml/browser/dist/compose/resolve-block-seq.js
function resolveBlockSeq({ composeNode: composeNode2, composeEmptyNode: composeEmptyNode2 }, ctx, bs, onError) {
    const seq2 = new YAMLSeq(ctx.schema);
    if (ctx.atRoot) ctx.atRoot = false;
    let offset = bs.offset;
    let commentEnd = null;
    for (const { start, value: value1 } of bs.items){
        const props = resolveProps(start, {
            indicator: "seq-item-ind",
            next: value1,
            offset,
            onError,
            startOnNewline: true
        });
        if (!props.found) {
            if (props.anchor || props.tag || value1) {
                if (value1 && value1.type === "block-seq") onError(props.end, "BAD_INDENT", "All sequence items must start at the same column");
                else onError(offset, "MISSING_CHAR", "Sequence item without - indicator");
            } else {
                commentEnd = props.end;
                if (props.comment) seq2.comment = props.comment;
                continue;
            }
        }
        const node = value1 ? composeNode2(ctx, value1, props, onError) : composeEmptyNode2(ctx, props.end, start, null, props, onError);
        if (ctx.schema.compat) flowIndentCheck(bs.indent, value1, onError);
        offset = node.range[2];
        seq2.items.push(node);
    }
    seq2.range = [
        bs.offset,
        offset,
        commentEnd != null ? commentEnd : offset
    ];
    return seq2;
}
// ../../node_modules/yaml/browser/dist/compose/resolve-end.js
function resolveEnd(end, offset, reqSpace, onError) {
    let comment = "";
    if (end) {
        let hasSpace = false;
        let sep = "";
        for (const token of end){
            const { source, type } = token;
            switch(type){
                case "space":
                    hasSpace = true;
                    break;
                case "comment":
                    {
                        if (reqSpace && !hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
                        const cb = source.substring(1) || " ";
                        if (!comment) comment = cb;
                        else comment += sep + cb;
                        sep = "";
                        break;
                    }
                case "newline":
                    if (comment) sep += source;
                    hasSpace = true;
                    break;
                default:
                    onError(token, "UNEXPECTED_TOKEN", `Unexpected ${type} at node end`);
            }
            offset += source.length;
        }
    }
    return {
        comment,
        offset
    };
}
// ../../node_modules/yaml/browser/dist/compose/resolve-flow-collection.js
var blockMsg = "Block collections are not allowed within flow collections";
var isBlock = (token)=>token && (token.type === "block-map" || token.type === "block-seq");
function resolveFlowCollection({ composeNode: composeNode2, composeEmptyNode: composeEmptyNode2 }, ctx, fc, onError) {
    var _a;
    const isMap2 = fc.start.source === "{";
    const fcName = isMap2 ? "flow map" : "flow sequence";
    const coll = isMap2 ? new YAMLMap(ctx.schema) : new YAMLSeq(ctx.schema);
    coll.flow = true;
    const atRoot = ctx.atRoot;
    if (atRoot) ctx.atRoot = false;
    let offset = fc.offset + fc.start.source.length;
    for(let i = 0; i < fc.items.length; ++i){
        const collItem = fc.items[i];
        const { start, key, sep, value: value1 } = collItem;
        const props = resolveProps(start, {
            flow: fcName,
            indicator: "explicit-key-ind",
            next: key != null ? key : sep == null ? void 0 : sep[0],
            offset,
            onError,
            startOnNewline: false
        });
        if (!props.found) {
            if (!props.anchor && !props.tag && !sep && !value1) {
                if (i === 0 && props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
                else if (i < fc.items.length - 1) onError(props.start, "UNEXPECTED_TOKEN", `Unexpected empty item in ${fcName}`);
                if (props.comment) {
                    if (coll.comment) coll.comment += "\n" + props.comment;
                    else coll.comment = props.comment;
                }
                offset = props.end;
                continue;
            }
            if (!isMap2 && ctx.options.strict && containsNewline(key)) onError(key, // checked by containsNewline()
            "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
        }
        if (i === 0) {
            if (props.comma) onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
        } else {
            if (!props.comma) onError(props.start, "MISSING_CHAR", `Missing , between ${fcName} items`);
            if (props.comment) {
                let prevItemComment = "";
                loop: for (const st of start){
                    switch(st.type){
                        case "comma":
                        case "space":
                            break;
                        case "comment":
                            prevItemComment = st.source.substring(1);
                            break loop;
                        default:
                            break loop;
                    }
                }
                if (prevItemComment) {
                    let prev = coll.items[coll.items.length - 1];
                    if (isPair(prev)) prev = (_a = prev.value) != null ? _a : prev.key;
                    if (prev.comment) prev.comment += "\n" + prevItemComment;
                    else prev.comment = prevItemComment;
                    props.comment = props.comment.substring(prevItemComment.length + 1);
                }
            }
        }
        if (!isMap2 && !sep && !props.found) {
            const valueNode = value1 ? composeNode2(ctx, value1, props, onError) : composeEmptyNode2(ctx, props.end, sep, null, props, onError);
            coll.items.push(valueNode);
            offset = valueNode.range[2];
            if (isBlock(value1)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
        } else {
            const keyStart = props.end;
            const keyNode = key ? composeNode2(ctx, key, props, onError) : composeEmptyNode2(ctx, keyStart, start, null, props, onError);
            if (isBlock(key)) onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
            const valueProps = resolveProps(sep != null ? sep : [], {
                flow: fcName,
                indicator: "map-value-ind",
                next: value1,
                offset: keyNode.range[2],
                onError,
                startOnNewline: false
            });
            if (valueProps.found) {
                if (!isMap2 && !props.found && ctx.options.strict) {
                    if (sep) for (const st of sep){
                        if (st === valueProps.found) break;
                        if (st.type === "newline") {
                            onError(st, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
                            break;
                        }
                    }
                    if (props.start < valueProps.found.offset - 1024) onError(valueProps.found, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit flow sequence key");
                }
            } else if (value1) {
                if ("source" in value1 && value1.source && value1.source[0] === ":") onError(value1, "MISSING_CHAR", `Missing space after : in ${fcName}`);
                else onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
            }
            const valueNode = value1 ? composeNode2(ctx, value1, valueProps, onError) : valueProps.found ? composeEmptyNode2(ctx, valueProps.end, sep, null, valueProps, onError) : null;
            if (valueNode) {
                if (isBlock(value1)) onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
            } else if (valueProps.comment) {
                if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
                else keyNode.comment = valueProps.comment;
            }
            const pair = new Pair(keyNode, valueNode);
            if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
            if (isMap2) {
                const map2 = coll;
                if (mapIncludes(ctx, map2.items, keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
                map2.items.push(pair);
            } else {
                const map2 = new YAMLMap(ctx.schema);
                map2.flow = true;
                map2.items.push(pair);
                coll.items.push(map2);
            }
            offset = valueNode ? valueNode.range[2] : valueProps.end;
        }
    }
    const expectedEnd = isMap2 ? "}" : "]";
    const [ce, ...ee] = fc.end;
    let cePos = offset;
    if (ce && ce.source === expectedEnd) cePos = ce.offset + ce.source.length;
    else {
        const name = fcName[0].toUpperCase() + fcName.substring(1);
        const msg = atRoot ? `${name} must end with a ${expectedEnd}` : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
        onError(offset, atRoot ? "MISSING_CHAR" : "BAD_INDENT", msg);
        if (ce && ce.source.length !== 1) ee.unshift(ce);
    }
    if (ee.length > 0) {
        const end = resolveEnd(ee, cePos, ctx.options.strict, onError);
        if (end.comment) {
            if (coll.comment) coll.comment += "\n" + end.comment;
            else coll.comment = end.comment;
        }
        coll.range = [
            fc.offset,
            cePos,
            end.offset
        ];
    } else {
        coll.range = [
            fc.offset,
            cePos,
            cePos
        ];
    }
    return coll;
}
// ../../node_modules/yaml/browser/dist/compose/compose-collection.js
function composeCollection(CN2, ctx, token, tagToken, onError) {
    let coll;
    switch(token.type){
        case "block-map":
            {
                coll = resolveBlockMap(CN2, ctx, token, onError);
                break;
            }
        case "block-seq":
            {
                coll = resolveBlockSeq(CN2, ctx, token, onError);
                break;
            }
        case "flow-collection":
            {
                coll = resolveFlowCollection(CN2, ctx, token, onError);
                break;
            }
    }
    if (!tagToken) return coll;
    const tagName = ctx.directives.tagName(tagToken.source, (msg)=>onError(tagToken, "TAG_RESOLVE_FAILED", msg));
    if (!tagName) return coll;
    const Coll = coll.constructor;
    if (tagName === "!" || tagName === Coll.tagName) {
        coll.tag = Coll.tagName;
        return coll;
    }
    const expType = isMap(coll) ? "map" : "seq";
    let tag = ctx.schema.tags.find((t1)=>t1.collection === expType && t1.tag === tagName);
    if (!tag) {
        const kt = ctx.schema.knownTags[tagName];
        if (kt && kt.collection === expType) {
            ctx.schema.tags.push(Object.assign({}, kt, {
                default: false
            }));
            tag = kt;
        } else {
            onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, true);
            coll.tag = tagName;
            return coll;
        }
    }
    const res = tag.resolve(coll, (msg)=>onError(tagToken, "TAG_RESOLVE_FAILED", msg), ctx.options);
    const node = isNode(res) ? res : new Scalar(res);
    node.range = coll.range;
    node.tag = tagName;
    if (tag == null ? void 0 : tag.format) node.format = tag.format;
    return node;
}
// ../../node_modules/yaml/browser/dist/compose/resolve-block-scalar.js
function resolveBlockScalar(scalar, strict, onError) {
    const start = scalar.offset;
    const header = parseBlockScalarHeader(scalar, strict, onError);
    if (!header) return {
        value: "",
        type: null,
        comment: "",
        range: [
            start,
            start,
            start
        ]
    };
    const type = header.mode === ">" ? Scalar.BLOCK_FOLDED : Scalar.BLOCK_LITERAL;
    const lines = scalar.source ? splitLines(scalar.source) : [];
    let chompStart = lines.length;
    for(let i = lines.length - 1; i >= 0; --i){
        const content = lines[i][1];
        if (content === "" || content === "\r") chompStart = i;
        else break;
    }
    if (chompStart === 0) {
        const value2 = header.chomp === "+" && lines.length > 0 ? "\n".repeat(Math.max(1, lines.length - 1)) : "";
        let end2 = start + header.length;
        if (scalar.source) end2 += scalar.source.length;
        return {
            value: value2,
            type,
            comment: header.comment,
            range: [
                start,
                end2,
                end2
            ]
        };
    }
    let trimIndent = scalar.indent + header.indent;
    let offset = scalar.offset + header.length;
    let contentStart = 0;
    for(let i = 0; i < chompStart; ++i){
        const [indent, content] = lines[i];
        if (content === "" || content === "\r") {
            if (header.indent === 0 && indent.length > trimIndent) trimIndent = indent.length;
        } else {
            if (indent.length < trimIndent) {
                const message = "Block scalars with more-indented leading empty lines must use an explicit indentation indicator";
                onError(offset + indent.length, "MISSING_CHAR", message);
            }
            if (header.indent === 0) trimIndent = indent.length;
            contentStart = i;
            break;
        }
        offset += indent.length + content.length + 1;
    }
    for(let i = lines.length - 1; i >= chompStart; --i){
        if (lines[i][0].length > trimIndent) chompStart = i + 1;
    }
    let value1 = "";
    let sep = "";
    let prevMoreIndented = false;
    for(let i = 0; i < contentStart; ++i)value1 += lines[i][0].slice(trimIndent) + "\n";
    for(let i = contentStart; i < chompStart; ++i){
        let [indent, content] = lines[i];
        offset += indent.length + content.length + 1;
        const crlf = content[content.length - 1] === "\r";
        if (crlf) content = content.slice(0, -1);
        if (content && indent.length < trimIndent) {
            const src = header.indent ? "explicit indentation indicator" : "first line";
            const message = `Block scalar lines must not be less indented than their ${src}`;
            onError(offset - content.length - (crlf ? 2 : 1), "BAD_INDENT", message);
            indent = "";
        }
        if (type === Scalar.BLOCK_LITERAL) {
            value1 += sep + indent.slice(trimIndent) + content;
            sep = "\n";
        } else if (indent.length > trimIndent || content[0] === "	") {
            if (sep === " ") sep = "\n";
            else if (!prevMoreIndented && sep === "\n") sep = "\n\n";
            value1 += sep + indent.slice(trimIndent) + content;
            sep = "\n";
            prevMoreIndented = true;
        } else if (content === "") {
            if (sep === "\n") value1 += "\n";
            else sep = "\n";
        } else {
            value1 += sep + content;
            sep = " ";
            prevMoreIndented = false;
        }
    }
    switch(header.chomp){
        case "-":
            break;
        case "+":
            for(let i = chompStart; i < lines.length; ++i)value1 += "\n" + lines[i][0].slice(trimIndent);
            if (value1[value1.length - 1] !== "\n") value1 += "\n";
            break;
        default:
            value1 += "\n";
    }
    const end = start + header.length + scalar.source.length;
    return {
        value: value1,
        type,
        comment: header.comment,
        range: [
            start,
            end,
            end
        ]
    };
}
function parseBlockScalarHeader({ offset, props }, strict, onError) {
    if (props[0].type !== "block-scalar-header") {
        onError(props[0], "IMPOSSIBLE", "Block scalar header not found");
        return null;
    }
    const { source } = props[0];
    const mode = source[0];
    let indent = 0;
    let chomp = "";
    let error = -1;
    for(let i = 1; i < source.length; ++i){
        const ch = source[i];
        if (!chomp && (ch === "-" || ch === "+")) chomp = ch;
        else {
            const n = Number(ch);
            if (!indent && n) indent = n;
            else if (error === -1) error = offset + i;
        }
    }
    if (error !== -1) onError(error, "UNEXPECTED_TOKEN", `Block scalar header includes extra characters: ${source}`);
    let hasSpace = false;
    let comment = "";
    let length = source.length;
    for(let i = 1; i < props.length; ++i){
        const token = props[i];
        switch(token.type){
            case "space":
                hasSpace = true;
            case "newline":
                length += token.source.length;
                break;
            case "comment":
                if (strict && !hasSpace) {
                    const message = "Comments must be separated from other tokens by white space characters";
                    onError(token, "MISSING_CHAR", message);
                }
                length += token.source.length;
                comment = token.source.substring(1);
                break;
            case "error":
                onError(token, "UNEXPECTED_TOKEN", token.message);
                length += token.source.length;
                break;
            default:
                {
                    const message = `Unexpected token in block scalar header: ${token.type}`;
                    onError(token, "UNEXPECTED_TOKEN", message);
                    const ts = token.source;
                    if (ts && typeof ts === "string") length += ts.length;
                }
        }
    }
    return {
        mode,
        indent,
        chomp,
        comment,
        length
    };
}
function splitLines(source) {
    const split = source.split(/\n( *)/);
    const first = split[0];
    const m = first.match(/^( *)/);
    const line0 = (m == null ? void 0 : m[1]) ? [
        m[1],
        first.slice(m[1].length)
    ] : [
        "",
        first
    ];
    const lines = [
        line0
    ];
    for(let i = 1; i < split.length; i += 2)lines.push([
        split[i],
        split[i + 1]
    ]);
    return lines;
}
// ../../node_modules/yaml/browser/dist/compose/resolve-flow-scalar.js
function resolveFlowScalar(scalar, strict, onError) {
    const { offset, type, source, end } = scalar;
    let _type;
    let value1;
    const _onError = (rel, code, msg)=>onError(offset + rel, code, msg);
    switch(type){
        case "scalar":
            _type = Scalar.PLAIN;
            value1 = plainValue(source, _onError);
            break;
        case "single-quoted-scalar":
            _type = Scalar.QUOTE_SINGLE;
            value1 = singleQuotedValue(source, _onError);
            break;
        case "double-quoted-scalar":
            _type = Scalar.QUOTE_DOUBLE;
            value1 = doubleQuotedValue(source, _onError);
            break;
        default:
            onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
            return {
                value: "",
                type: null,
                comment: "",
                range: [
                    offset,
                    offset + source.length,
                    offset + source.length
                ]
            };
    }
    const valueEnd = offset + source.length;
    const re = resolveEnd(end, valueEnd, strict, onError);
    return {
        value: value1,
        type: _type,
        comment: re.comment,
        range: [
            offset,
            valueEnd,
            re.offset
        ]
    };
}
function plainValue(source, onError) {
    let badChar = "";
    switch(source[0]){
        case "	":
            badChar = "a tab character";
            break;
        case ",":
            badChar = "flow indicator character ,";
            break;
        case "%":
            badChar = "directive indicator character %";
            break;
        case "|":
        case ">":
            {
                badChar = `block scalar indicator ${source[0]}`;
                break;
            }
        case "@":
        case "`":
            {
                badChar = `reserved character ${source[0]}`;
                break;
            }
    }
    if (badChar) onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
    return foldLines(source);
}
function singleQuotedValue(source, onError) {
    if (source[source.length - 1] !== "'" || source.length === 1) onError(source.length, "MISSING_CHAR", "Missing closing 'quote");
    return foldLines(source.slice(1, -1)).replace(/''/g, "'");
}
function foldLines(source) {
    var _a;
    let first, line;
    try {
        first = new RegExp("(.*?)(?<![ 	])[ 	]*\r?\n", "sy");
        line = new RegExp("[ 	]*(.*?)(?:(?<![ 	])[ 	]*)?\r?\n", "sy");
    } catch (_2) {
        first = RegExp("(.*?)[ \\t]*\\r?\\n", "sy");
        line = RegExp("[ \\t]*(.*?)[ \\t]*\\r?\\n", "sy");
    }
    let match = first.exec(source);
    if (!match) return source;
    let res = match[1];
    let sep = " ";
    let pos = first.lastIndex;
    line.lastIndex = pos;
    while(match = line.exec(source)){
        if (match[1] === "") {
            if (sep === "\n") res += sep;
            else sep = "\n";
        } else {
            res += sep + match[1];
            sep = " ";
        }
        pos = line.lastIndex;
    }
    const last = RegExp("[ \\t]*(.*)", "sy");
    last.lastIndex = pos;
    match = last.exec(source);
    return res + sep + ((_a = match == null ? void 0 : match[1]) != null ? _a : "");
}
function doubleQuotedValue(source, onError) {
    let res = "";
    for(let i = 1; i < source.length - 1; ++i){
        const ch = source[i];
        if (ch === "\r" && source[i + 1] === "\n") continue;
        if (ch === "\n") {
            const { fold, offset } = foldNewline(source, i);
            res += fold;
            i = offset;
        } else if (ch === "\\") {
            let next = source[++i];
            const cc = escapeCodes[next];
            if (cc) res += cc;
            else if (next === "\n") {
                next = source[i + 1];
                while(next === " " || next === "	")next = source[++i + 1];
            } else if (next === "\r" && source[i + 1] === "\n") {
                next = source[++i + 1];
                while(next === " " || next === "	")next = source[++i + 1];
            } else if (next === "x" || next === "u" || next === "U") {
                const length = {
                    x: 2,
                    u: 4,
                    U: 8
                }[next];
                res += parseCharCode(source, i + 1, length, onError);
                i += length;
            } else {
                const raw = source.substr(i - 1, 2);
                onError(i - 1, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
                res += raw;
            }
        } else if (ch === " " || ch === "	") {
            const wsStart = i;
            let next = source[i + 1];
            while(next === " " || next === "	")next = source[++i + 1];
            if (next !== "\n" && !(next === "\r" && source[i + 2] === "\n")) res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
        } else {
            res += ch;
        }
    }
    if (source[source.length - 1] !== '"' || source.length === 1) onError(source.length, "MISSING_CHAR", 'Missing closing "quote');
    return res;
}
function foldNewline(source, offset) {
    let fold = "";
    let ch = source[offset + 1];
    while(ch === " " || ch === "	" || ch === "\n" || ch === "\r"){
        if (ch === "\r" && source[offset + 2] !== "\n") break;
        if (ch === "\n") fold += "\n";
        offset += 1;
        ch = source[offset + 1];
    }
    if (!fold) fold = " ";
    return {
        fold,
        offset
    };
}
var escapeCodes = {
    "0": "\0",
    a: "\x07",
    b: "\b",
    e: "\x1B",
    f: "\f",
    n: "\n",
    r: "\r",
    t: "	",
    v: "\v",
    N: "\x85",
    _: "\xA0",
    L: "\u2028",
    P: "\u2029",
    " ": " ",
    '"': '"',
    "/": "/",
    "\\": "\\",
    "	": "	"
};
function parseCharCode(source, offset, length, onError) {
    const cc = source.substr(offset, length);
    const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
    const code = ok ? parseInt(cc, 16) : NaN;
    if (isNaN(code)) {
        const raw = source.substr(offset - 2, length + 2);
        onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
        return raw;
    }
    return String.fromCodePoint(code);
}
// ../../node_modules/yaml/browser/dist/compose/compose-scalar.js
function composeScalar(ctx, token, tagToken, onError) {
    const { value: value1, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar(token, ctx.options.strict, onError) : resolveFlowScalar(token, ctx.options.strict, onError);
    const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg)=>onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
    const tag = tagToken && tagName ? findScalarTagByName(ctx.schema, value1, tagName, tagToken, onError) : token.type === "scalar" ? findScalarTagByTest(ctx, value1, token, onError) : ctx.schema[SCALAR];
    let scalar;
    try {
        const res = tag.resolve(value1, (msg)=>onError(tagToken != null ? tagToken : token, "TAG_RESOLVE_FAILED", msg), ctx.options);
        scalar = isScalar(res) ? res : new Scalar(res);
    } catch (error) {
        const msg = error instanceof Error ? error.message : String(error);
        onError(tagToken != null ? tagToken : token, "TAG_RESOLVE_FAILED", msg);
        scalar = new Scalar(value1);
    }
    scalar.range = range;
    scalar.source = value1;
    if (type) scalar.type = type;
    if (tagName) scalar.tag = tagName;
    if (tag.format) scalar.format = tag.format;
    if (comment) scalar.comment = comment;
    return scalar;
}
function findScalarTagByName(schema4, value1, tagName, tagToken, onError) {
    var _a;
    if (tagName === "!") return schema4[SCALAR];
    const matchWithTest = [];
    for (const tag of schema4.tags){
        if (!tag.collection && tag.tag === tagName) {
            if (tag.default && tag.test) matchWithTest.push(tag);
            else return tag;
        }
    }
    for (const tag of matchWithTest)if ((_a = tag.test) == null ? void 0 : _a.test(value1)) return tag;
    const kt = schema4.knownTags[tagName];
    if (kt && !kt.collection) {
        schema4.tags.push(Object.assign({}, kt, {
            default: false,
            test: void 0
        }));
        return kt;
    }
    onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
    return schema4[SCALAR];
}
function findScalarTagByTest({ directives, schema: schema4 }, value1, token, onError) {
    var _a;
    const tag = schema4.tags.find((tag2)=>{
        var _a2;
        return tag2.default && ((_a2 = tag2.test) == null ? void 0 : _a2.test(value1));
    }) || schema4[SCALAR];
    if (schema4.compat) {
        const compat = (_a = schema4.compat.find((tag2)=>{
            var _a2;
            return tag2.default && ((_a2 = tag2.test) == null ? void 0 : _a2.test(value1));
        })) != null ? _a : schema4[SCALAR];
        if (tag.tag !== compat.tag) {
            const ts = directives.tagString(tag.tag);
            const cs = directives.tagString(compat.tag);
            const msg = `Value may be parsed as either ${ts} or ${cs}`;
            onError(token, "TAG_RESOLVE_FAILED", msg, true);
        }
    }
    return tag;
}
// ../../node_modules/yaml/browser/dist/compose/util-empty-scalar-position.js
function emptyScalarPosition(offset, before, pos) {
    if (before) {
        if (pos === null) pos = before.length;
        for(let i = pos - 1; i >= 0; --i){
            let st = before[i];
            switch(st.type){
                case "space":
                case "comment":
                case "newline":
                    offset -= st.source.length;
                    continue;
            }
            st = before[++i];
            while((st == null ? void 0 : st.type) === "space"){
                offset += st.source.length;
                st = before[++i];
            }
            break;
        }
    }
    return offset;
}
// ../../node_modules/yaml/browser/dist/compose/compose-node.js
var CN = {
    composeNode,
    composeEmptyNode
};
function composeNode(ctx, token, props, onError) {
    const { spaceBefore, comment, anchor, tag } = props;
    let node;
    let isSrcToken = true;
    switch(token.type){
        case "alias":
            node = composeAlias(ctx, token, onError);
            if (anchor || tag) onError(token, "ALIAS_PROPS", "An alias node must not specify any properties");
            break;
        case "scalar":
        case "single-quoted-scalar":
        case "double-quoted-scalar":
        case "block-scalar":
            node = composeScalar(ctx, token, tag, onError);
            if (anchor) node.anchor = anchor.source.substring(1);
            break;
        case "block-map":
        case "block-seq":
        case "flow-collection":
            node = composeCollection(CN, ctx, token, tag, onError);
            if (anchor) node.anchor = anchor.source.substring(1);
            break;
        default:
            {
                const message = token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`;
                onError(token, "UNEXPECTED_TOKEN", message);
                node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError);
                isSrcToken = false;
            }
    }
    if (anchor && node.anchor === "") onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
    if (spaceBefore) node.spaceBefore = true;
    if (comment) {
        if (token.type === "scalar" && token.source === "") node.comment = comment;
        else node.commentBefore = comment;
    }
    if (ctx.options.keepSourceTokens && isSrcToken) node.srcToken = token;
    return node;
}
function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
    const token = {
        type: "scalar",
        offset: emptyScalarPosition(offset, before, pos),
        indent: -1,
        source: ""
    };
    const node = composeScalar(ctx, token, tag, onError);
    if (anchor) {
        node.anchor = anchor.source.substring(1);
        if (node.anchor === "") onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
    }
    if (spaceBefore) node.spaceBefore = true;
    if (comment) {
        node.comment = comment;
        node.range[2] = end;
    }
    return node;
}
function composeAlias({ options }, { offset, source, end }, onError) {
    const alias = new Alias(source.substring(1));
    if (alias.source === "") onError(offset, "BAD_ALIAS", "Alias cannot be an empty string");
    if (alias.source.endsWith(":")) onError(offset + source.length - 1, "BAD_ALIAS", "Alias ending in : is ambiguous", true);
    const valueEnd = offset + source.length;
    const re = resolveEnd(end, valueEnd, options.strict, onError);
    alias.range = [
        offset,
        valueEnd,
        re.offset
    ];
    if (re.comment) alias.comment = re.comment;
    return alias;
}
// ../../node_modules/yaml/browser/dist/compose/compose-doc.js
function composeDoc(options, directives, { offset, start, value: value1, end }, onError) {
    const opts = Object.assign({
        _directives: directives
    }, options);
    const doc = new Document(void 0, opts);
    const ctx = {
        atRoot: true,
        directives: doc.directives,
        options: doc.options,
        schema: doc.schema
    };
    const props = resolveProps(start, {
        indicator: "doc-start",
        next: value1 != null ? value1 : end == null ? void 0 : end[0],
        offset,
        onError,
        startOnNewline: true
    });
    if (props.found) {
        doc.directives.docStart = true;
        if (value1 && (value1.type === "block-map" || value1.type === "block-seq") && !props.hasNewline) onError(props.end, "MISSING_CHAR", "Block collection cannot start on same line with directives-end marker");
    }
    doc.contents = value1 ? composeNode(ctx, value1, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
    const contentEnd = doc.contents.range[2];
    const re = resolveEnd(end, contentEnd, false, onError);
    if (re.comment) doc.comment = re.comment;
    doc.range = [
        offset,
        contentEnd,
        re.offset
    ];
    return doc;
}
// ../../node_modules/yaml/browser/dist/compose/composer.js
function getErrorPos(src) {
    if (typeof src === "number") return [
        src,
        src + 1
    ];
    if (Array.isArray(src)) return src.length === 2 ? src : [
        src[0],
        src[1]
    ];
    const { offset, source } = src;
    return [
        offset,
        offset + (typeof source === "string" ? source.length : 1)
    ];
}
function parsePrelude(prelude) {
    var _a;
    let comment = "";
    let atComment = false;
    let afterEmptyLine = false;
    for(let i = 0; i < prelude.length; ++i){
        const source = prelude[i];
        switch(source[0]){
            case "#":
                comment += (comment === "" ? "" : afterEmptyLine ? "\n\n" : "\n") + (source.substring(1) || " ");
                atComment = true;
                afterEmptyLine = false;
                break;
            case "%":
                if (((_a = prelude[i + 1]) == null ? void 0 : _a[0]) !== "#") i += 1;
                atComment = false;
                break;
            default:
                if (!atComment) afterEmptyLine = true;
                atComment = false;
        }
    }
    return {
        comment,
        afterEmptyLine
    };
}
var Composer = class {
    decorate(doc, afterDoc) {
        const { comment, afterEmptyLine } = parsePrelude(this.prelude);
        if (comment) {
            const dc = doc.contents;
            if (afterDoc) {
                doc.comment = doc.comment ? `${doc.comment}
${comment}` : comment;
            } else if (afterEmptyLine || doc.directives.docStart || !dc) {
                doc.commentBefore = comment;
            } else if (isCollection(dc) && !dc.flow && dc.items.length > 0) {
                let it = dc.items[0];
                if (isPair(it)) it = it.key;
                const cb = it.commentBefore;
                it.commentBefore = cb ? `${comment}
${cb}` : comment;
            } else {
                const cb = dc.commentBefore;
                dc.commentBefore = cb ? `${comment}
${cb}` : comment;
            }
        }
        if (afterDoc) {
            Array.prototype.push.apply(doc.errors, this.errors);
            Array.prototype.push.apply(doc.warnings, this.warnings);
        } else {
            doc.errors = this.errors;
            doc.warnings = this.warnings;
        }
        this.prelude = [];
        this.errors = [];
        this.warnings = [];
    }
    /**
   * Current stream status information.
   *
   * Mostly useful at the end of input for an empty stream.
   */ streamInfo() {
        return {
            comment: parsePrelude(this.prelude).comment,
            directives: this.directives,
            errors: this.errors,
            warnings: this.warnings
        };
    }
    /**
   * Compose tokens into documents.
   *
   * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
   * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
   */ *compose(tokens, forceDoc = false, endOffset = -1) {
        for (const token of tokens)yield* this.next(token);
        yield* this.end(forceDoc, endOffset);
    }
    /** Advance the composer by one CST token. */ *next(token) {
        switch(token.type){
            case "directive":
                this.directives.add(token.source, (offset, message, warning)=>{
                    const pos = getErrorPos(token);
                    pos[0] += offset;
                    this.onError(pos, "BAD_DIRECTIVE", message, warning);
                });
                this.prelude.push(token.source);
                this.atDirectives = true;
                break;
            case "document":
                {
                    const doc = composeDoc(this.options, this.directives, token, this.onError);
                    if (this.atDirectives && !doc.directives.docStart) this.onError(token, "MISSING_CHAR", "Missing directives-end/doc-start indicator line");
                    this.decorate(doc, false);
                    if (this.doc) yield this.doc;
                    this.doc = doc;
                    this.atDirectives = false;
                    break;
                }
            case "byte-order-mark":
            case "space":
                break;
            case "comment":
            case "newline":
                this.prelude.push(token.source);
                break;
            case "error":
                {
                    const msg = token.source ? `${token.message}: ${JSON.stringify(token.source)}` : token.message;
                    const error = new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg);
                    if (this.atDirectives || !this.doc) this.errors.push(error);
                    else this.doc.errors.push(error);
                    break;
                }
            case "doc-end":
                {
                    if (!this.doc) {
                        const msg = "Unexpected doc-end without preceding document";
                        this.errors.push(new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg));
                        break;
                    }
                    this.doc.directives.docEnd = true;
                    const end = resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
                    this.decorate(this.doc, true);
                    if (end.comment) {
                        const dc = this.doc.comment;
                        this.doc.comment = dc ? `${dc}
${end.comment}` : end.comment;
                    }
                    this.doc.range[2] = end.offset;
                    break;
                }
            default:
                this.errors.push(new YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", `Unsupported token ${token.type}`));
        }
    }
    /**
   * Call at end of input to yield any remaining document.
   *
   * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
   * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
   */ *end(forceDoc = false, endOffset = -1) {
        if (this.doc) {
            this.decorate(this.doc, true);
            yield this.doc;
            this.doc = null;
        } else if (forceDoc) {
            const opts = Object.assign({
                _directives: this.directives
            }, this.options);
            const doc = new Document(void 0, opts);
            if (this.atDirectives) this.onError(endOffset, "MISSING_CHAR", "Missing directives-end indicator line");
            doc.range = [
                0,
                endOffset,
                endOffset
            ];
            this.decorate(doc, false);
            yield doc;
        }
    }
    constructor(options = {}){
        this.doc = null;
        this.atDirectives = false;
        this.prelude = [];
        this.errors = [];
        this.warnings = [];
        this.onError = (source, code, message, warning)=>{
            const pos = getErrorPos(source);
            if (warning) this.warnings.push(new YAMLWarning(pos, code, message));
            else this.errors.push(new YAMLParseError(pos, code, message));
        };
        this.directives = new Directives({
            version: options.version || "1.2"
        });
        this.options = options;
    }
};
// ../../node_modules/yaml/browser/dist/parse/cst.js
var cst_exports = {};
__export(cst_exports, {
    BOM: ()=>BOM,
    DOCUMENT: ()=>DOCUMENT,
    FLOW_END: ()=>FLOW_END,
    SCALAR: ()=>SCALAR2,
    createScalarToken: ()=>createScalarToken,
    isCollection: ()=>isCollection2,
    isScalar: ()=>isScalar2,
    prettyToken: ()=>prettyToken,
    resolveAsScalar: ()=>resolveAsScalar,
    setScalarValue: ()=>setScalarValue,
    stringify: ()=>stringify2,
    tokenType: ()=>tokenType,
    visit: ()=>visit3
});
// ../../node_modules/yaml/browser/dist/parse/cst-scalar.js
function resolveAsScalar(token, strict = true, onError) {
    if (token) {
        const _onError = (pos, code, message)=>{
            const offset = typeof pos === "number" ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
            if (onError) onError(offset, code, message);
            else throw new YAMLParseError([
                offset,
                offset + 1
            ], code, message);
        };
        switch(token.type){
            case "scalar":
            case "single-quoted-scalar":
            case "double-quoted-scalar":
                return resolveFlowScalar(token, strict, _onError);
            case "block-scalar":
                return resolveBlockScalar(token, strict, _onError);
        }
    }
    return null;
}
function createScalarToken(value1, context) {
    var _a;
    const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context;
    const source = stringifyString({
        type,
        value: value1
    }, {
        implicitKey,
        indent: indent > 0 ? " ".repeat(indent) : "",
        inFlow,
        options: {
            blockQuote: true,
            lineWidth: -1
        }
    });
    const end = (_a = context.end) != null ? _a : [
        {
            type: "newline",
            offset: -1,
            indent,
            source: "\n"
        }
    ];
    switch(source[0]){
        case "|":
        case ">":
            {
                const he = source.indexOf("\n");
                const head = source.substring(0, he);
                const body = source.substring(he + 1) + "\n";
                const props = [
                    {
                        type: "block-scalar-header",
                        offset,
                        indent,
                        source: head
                    }
                ];
                if (!addEndtoBlockProps(props, end)) props.push({
                    type: "newline",
                    offset: -1,
                    indent,
                    source: "\n"
                });
                return {
                    type: "block-scalar",
                    offset,
                    indent,
                    props,
                    source: body
                };
            }
        case '"':
            return {
                type: "double-quoted-scalar",
                offset,
                indent,
                source,
                end
            };
        case "'":
            return {
                type: "single-quoted-scalar",
                offset,
                indent,
                source,
                end
            };
        default:
            return {
                type: "scalar",
                offset,
                indent,
                source,
                end
            };
    }
}
function setScalarValue(token, value1, context = {}) {
    let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
    let indent = "indent" in token ? token.indent : null;
    if (afterKey && typeof indent === "number") indent += 2;
    if (!type) switch(token.type){
        case "single-quoted-scalar":
            type = "QUOTE_SINGLE";
            break;
        case "double-quoted-scalar":
            type = "QUOTE_DOUBLE";
            break;
        case "block-scalar":
            {
                const header = token.props[0];
                if (header.type !== "block-scalar-header") throw new Error("Invalid block scalar header");
                type = header.source[0] === ">" ? "BLOCK_FOLDED" : "BLOCK_LITERAL";
                break;
            }
        default:
            type = "PLAIN";
    }
    const source = stringifyString({
        type,
        value: value1
    }, {
        implicitKey: implicitKey || indent === null,
        indent: indent !== null && indent > 0 ? " ".repeat(indent) : "",
        inFlow,
        options: {
            blockQuote: true,
            lineWidth: -1
        }
    });
    switch(source[0]){
        case "|":
        case ">":
            setBlockScalarValue(token, source);
            break;
        case '"':
            setFlowScalarValue(token, source, "double-quoted-scalar");
            break;
        case "'":
            setFlowScalarValue(token, source, "single-quoted-scalar");
            break;
        default:
            setFlowScalarValue(token, source, "scalar");
    }
}
function setBlockScalarValue(token, source) {
    const he = source.indexOf("\n");
    const head = source.substring(0, he);
    const body = source.substring(he + 1) + "\n";
    if (token.type === "block-scalar") {
        const header = token.props[0];
        if (header.type !== "block-scalar-header") throw new Error("Invalid block scalar header");
        header.source = head;
        token.source = body;
    } else {
        const { offset } = token;
        const indent = "indent" in token ? token.indent : -1;
        const props = [
            {
                type: "block-scalar-header",
                offset,
                indent,
                source: head
            }
        ];
        if (!addEndtoBlockProps(props, "end" in token ? token.end : void 0)) props.push({
            type: "newline",
            offset: -1,
            indent,
            source: "\n"
        });
        for (const key of Object.keys(token))if (key !== "type" && key !== "offset") delete token[key];
        Object.assign(token, {
            type: "block-scalar",
            indent,
            props,
            source: body
        });
    }
}
function addEndtoBlockProps(props, end) {
    if (end) for (const st of end)switch(st.type){
        case "space":
        case "comment":
            props.push(st);
            break;
        case "newline":
            props.push(st);
            return true;
    }
    return false;
}
function setFlowScalarValue(token, source, type) {
    switch(token.type){
        case "scalar":
        case "double-quoted-scalar":
        case "single-quoted-scalar":
            token.type = type;
            token.source = source;
            break;
        case "block-scalar":
            {
                const end = token.props.slice(1);
                let oa = source.length;
                if (token.props[0].type === "block-scalar-header") oa -= token.props[0].source.length;
                for (const tok of end)tok.offset += oa;
                delete token.props;
                Object.assign(token, {
                    type,
                    source,
                    end
                });
                break;
            }
        case "block-map":
        case "block-seq":
            {
                const offset = token.offset + source.length;
                const nl = {
                    type: "newline",
                    offset,
                    indent: token.indent,
                    source: "\n"
                };
                delete token.items;
                Object.assign(token, {
                    type,
                    source,
                    end: [
                        nl
                    ]
                });
                break;
            }
        default:
            {
                const indent = "indent" in token ? token.indent : -1;
                const end = "end" in token && Array.isArray(token.end) ? token.end.filter((st)=>st.type === "space" || st.type === "comment" || st.type === "newline") : [];
                for (const key of Object.keys(token))if (key !== "type" && key !== "offset") delete token[key];
                Object.assign(token, {
                    type,
                    indent,
                    source,
                    end
                });
            }
    }
}
// ../../node_modules/yaml/browser/dist/parse/cst-stringify.js
var stringify2 = (cst)=>"type" in cst ? stringifyToken(cst) : stringifyItem(cst);
function stringifyToken(token) {
    switch(token.type){
        case "block-scalar":
            {
                let res = "";
                for (const tok of token.props)res += stringifyToken(tok);
                return res + token.source;
            }
        case "block-map":
        case "block-seq":
            {
                let res = "";
                for (const item of token.items)res += stringifyItem(item);
                return res;
            }
        case "flow-collection":
            {
                let res = token.start.source;
                for (const item of token.items)res += stringifyItem(item);
                for (const st of token.end)res += st.source;
                return res;
            }
        case "document":
            {
                let res = stringifyItem(token);
                if (token.end) for (const st of token.end)res += st.source;
                return res;
            }
        default:
            {
                let res = token.source;
                if ("end" in token && token.end) for (const st of token.end)res += st.source;
                return res;
            }
    }
}
function stringifyItem({ start, key, sep, value: value1 }) {
    let res = "";
    for (const st of start)res += st.source;
    if (key) res += stringifyToken(key);
    if (sep) for (const st of sep)res += st.source;
    if (value1) res += stringifyToken(value1);
    return res;
}
// ../../node_modules/yaml/browser/dist/parse/cst-visit.js
var BREAK2 = Symbol("break visit");
var SKIP2 = Symbol("skip children");
var REMOVE2 = Symbol("remove item");
function visit3(cst, visitor) {
    if ("type" in cst && cst.type === "document") cst = {
        start: cst.start,
        value: cst.value
    };
    _visit(Object.freeze([]), cst, visitor);
}
visit3.BREAK = BREAK2;
visit3.SKIP = SKIP2;
visit3.REMOVE = REMOVE2;
visit3.itemAtPath = (cst, path5)=>{
    let item = cst;
    for (const [field, index] of path5){
        const tok = item == null ? void 0 : item[field];
        if (tok && "items" in tok) {
            item = tok.items[index];
        } else return void 0;
    }
    return item;
};
visit3.parentCollection = (cst, path5)=>{
    const parent = visit3.itemAtPath(cst, path5.slice(0, -1));
    const field = path5[path5.length - 1][0];
    const coll = parent == null ? void 0 : parent[field];
    if (coll && "items" in coll) return coll;
    throw new Error("Parent collection not found");
};
function _visit(path5, item, visitor) {
    let ctrl = visitor(item, path5);
    if (typeof ctrl === "symbol") return ctrl;
    for (const field of [
        "key",
        "value"
    ]){
        const token = item[field];
        if (token && "items" in token) {
            for(let i = 0; i < token.items.length; ++i){
                const ci = _visit(Object.freeze(path5.concat([
                    [
                        field,
                        i
                    ]
                ])), token.items[i], visitor);
                if (typeof ci === "number") i = ci - 1;
                else if (ci === BREAK2) return BREAK2;
                else if (ci === REMOVE2) {
                    token.items.splice(i, 1);
                    i -= 1;
                }
            }
            if (typeof ctrl === "function" && field === "key") ctrl = ctrl(item, path5);
        }
    }
    return typeof ctrl === "function" ? ctrl(item, path5) : ctrl;
}
// ../../node_modules/yaml/browser/dist/parse/cst.js
var BOM = "\uFEFF";
var DOCUMENT = "";
var FLOW_END = "";
var SCALAR2 = "";
var isCollection2 = (token)=>!!token && "items" in token;
var isScalar2 = (token)=>!!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar");
function prettyToken(token) {
    switch(token){
        case BOM:
            return "<BOM>";
        case DOCUMENT:
            return "<DOC>";
        case FLOW_END:
            return "<FLOW_END>";
        case SCALAR2:
            return "<SCALAR>";
        default:
            return JSON.stringify(token);
    }
}
function tokenType(source) {
    switch(source){
        case BOM:
            return "byte-order-mark";
        case DOCUMENT:
            return "doc-mode";
        case FLOW_END:
            return "flow-error-end";
        case SCALAR2:
            return "scalar";
        case "---":
            return "doc-start";
        case "...":
            return "doc-end";
        case "":
        case "\n":
        case "\r\n":
            return "newline";
        case "-":
            return "seq-item-ind";
        case "?":
            return "explicit-key-ind";
        case ":":
            return "map-value-ind";
        case "{":
            return "flow-map-start";
        case "}":
            return "flow-map-end";
        case "[":
            return "flow-seq-start";
        case "]":
            return "flow-seq-end";
        case ",":
            return "comma";
    }
    switch(source[0]){
        case " ":
        case "	":
            return "space";
        case "#":
            return "comment";
        case "%":
            return "directive-line";
        case "*":
            return "alias";
        case "&":
            return "anchor";
        case "!":
            return "tag";
        case "'":
            return "single-quoted-scalar";
        case '"':
            return "double-quoted-scalar";
        case "|":
        case ">":
            return "block-scalar-header";
    }
    return null;
}
// ../../node_modules/yaml/browser/dist/parse/lexer.js
function isEmpty(ch) {
    switch(ch){
        case void 0:
        case " ":
        case "\n":
        case "\r":
        case "	":
            return true;
        default:
            return false;
    }
}
var hexDigits = "0123456789ABCDEFabcdef".split("");
var tagChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()".split("");
var invalidFlowScalarChars = ",[]{}".split("");
var invalidAnchorChars = " ,[]{}\n\r	".split("");
var isNotAnchorChar = (ch)=>!ch || invalidAnchorChars.includes(ch);
var Lexer = class {
    /**
   * Generate YAML tokens from the `source` string. If `incomplete`,
   * a part of the last line may be left as a buffer for the next call.
   *
   * @returns A generator of lexical tokens
   */ *lex(source, incomplete = false) {
        var _a;
        if (source) {
            this.buffer = this.buffer ? this.buffer + source : source;
            this.lineEndPos = null;
        }
        this.atEnd = !incomplete;
        let next = (_a = this.next) != null ? _a : "stream";
        while(next && (incomplete || this.hasChars(1)))next = yield* this.parseNext(next);
    }
    atLineEnd() {
        let i = this.pos;
        let ch = this.buffer[i];
        while(ch === " " || ch === "	")ch = this.buffer[++i];
        if (!ch || ch === "#" || ch === "\n") return true;
        if (ch === "\r") return this.buffer[i + 1] === "\n";
        return false;
    }
    charAt(n) {
        return this.buffer[this.pos + n];
    }
    continueScalar(offset) {
        let ch = this.buffer[offset];
        if (this.indentNext > 0) {
            let indent = 0;
            while(ch === " ")ch = this.buffer[++indent + offset];
            if (ch === "\r") {
                const next = this.buffer[indent + offset + 1];
                if (next === "\n" || !next && !this.atEnd) return offset + indent + 1;
            }
            return ch === "\n" || indent >= this.indentNext || !ch && !this.atEnd ? offset + indent : -1;
        }
        if (ch === "-" || ch === ".") {
            const dt = this.buffer.substr(offset, 3);
            if ((dt === "---" || dt === "...") && isEmpty(this.buffer[offset + 3])) return -1;
        }
        return offset;
    }
    getLine() {
        let end = this.lineEndPos;
        if (typeof end !== "number" || end !== -1 && end < this.pos) {
            end = this.buffer.indexOf("\n", this.pos);
            this.lineEndPos = end;
        }
        if (end === -1) return this.atEnd ? this.buffer.substring(this.pos) : null;
        if (this.buffer[end - 1] === "\r") end -= 1;
        return this.buffer.substring(this.pos, end);
    }
    hasChars(n) {
        return this.pos + n <= this.buffer.length;
    }
    setNext(state) {
        this.buffer = this.buffer.substring(this.pos);
        this.pos = 0;
        this.lineEndPos = null;
        this.next = state;
        return null;
    }
    peek(n) {
        return this.buffer.substr(this.pos, n);
    }
    *parseNext(next) {
        switch(next){
            case "stream":
                return yield* this.parseStream();
            case "line-start":
                return yield* this.parseLineStart();
            case "block-start":
                return yield* this.parseBlockStart();
            case "doc":
                return yield* this.parseDocument();
            case "flow":
                return yield* this.parseFlowCollection();
            case "quoted-scalar":
                return yield* this.parseQuotedScalar();
            case "block-scalar":
                return yield* this.parseBlockScalar();
            case "plain-scalar":
                return yield* this.parsePlainScalar();
        }
    }
    *parseStream() {
        let line = this.getLine();
        if (line === null) return this.setNext("stream");
        if (line[0] === BOM) {
            yield* this.pushCount(1);
            line = line.substring(1);
        }
        if (line[0] === "%") {
            let dirEnd = line.length;
            const cs = line.indexOf("#");
            if (cs !== -1) {
                const ch = line[cs - 1];
                if (ch === " " || ch === "	") dirEnd = cs - 1;
            }
            while(true){
                const ch = line[dirEnd - 1];
                if (ch === " " || ch === "	") dirEnd -= 1;
                else break;
            }
            const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true));
            yield* this.pushCount(line.length - n);
            this.pushNewline();
            return "stream";
        }
        if (this.atLineEnd()) {
            const sp = yield* this.pushSpaces(true);
            yield* this.pushCount(line.length - sp);
            yield* this.pushNewline();
            return "stream";
        }
        yield DOCUMENT;
        return yield* this.parseLineStart();
    }
    *parseLineStart() {
        const ch = this.charAt(0);
        if (!ch && !this.atEnd) return this.setNext("line-start");
        if (ch === "-" || ch === ".") {
            if (!this.atEnd && !this.hasChars(4)) return this.setNext("line-start");
            const s = this.peek(3);
            if (s === "---" && isEmpty(this.charAt(3))) {
                yield* this.pushCount(3);
                this.indentValue = 0;
                this.indentNext = 0;
                return "doc";
            } else if (s === "..." && isEmpty(this.charAt(3))) {
                yield* this.pushCount(3);
                return "stream";
            }
        }
        this.indentValue = yield* this.pushSpaces(false);
        if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1))) this.indentNext = this.indentValue;
        return yield* this.parseBlockStart();
    }
    *parseBlockStart() {
        const [ch0, ch1] = this.peek(2);
        if (!ch1 && !this.atEnd) return this.setNext("block-start");
        if ((ch0 === "-" || ch0 === "?" || ch0 === ":") && isEmpty(ch1)) {
            const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
            this.indentNext = this.indentValue + 1;
            this.indentValue += n;
            return yield* this.parseBlockStart();
        }
        return "doc";
    }
    *parseDocument() {
        yield* this.pushSpaces(true);
        const line = this.getLine();
        if (line === null) return this.setNext("doc");
        let n = yield* this.pushIndicators();
        switch(line[n]){
            case "#":
                yield* this.pushCount(line.length - n);
            case void 0:
                yield* this.pushNewline();
                return yield* this.parseLineStart();
            case "{":
            case "[":
                yield* this.pushCount(1);
                this.flowKey = false;
                this.flowLevel = 1;
                return "flow";
            case "}":
            case "]":
                yield* this.pushCount(1);
                return "doc";
            case "*":
                yield* this.pushUntil(isNotAnchorChar);
                return "doc";
            case '"':
            case "'":
                return yield* this.parseQuotedScalar();
            case "|":
            case ">":
                n += yield* this.parseBlockScalarHeader();
                n += yield* this.pushSpaces(true);
                yield* this.pushCount(line.length - n);
                yield* this.pushNewline();
                return yield* this.parseBlockScalar();
            default:
                return yield* this.parsePlainScalar();
        }
    }
    *parseFlowCollection() {
        let nl, sp;
        let indent = -1;
        do {
            nl = yield* this.pushNewline();
            if (nl > 0) {
                sp = yield* this.pushSpaces(false);
                this.indentValue = indent = sp;
            } else {
                sp = 0;
            }
            sp += yield* this.pushSpaces(true);
        }while (nl + sp > 0)
        const line = this.getLine();
        if (line === null) return this.setNext("flow");
        if (indent !== -1 && indent < this.indentNext && line[0] !== "#" || indent === 0 && (line.startsWith("---") || line.startsWith("...")) && isEmpty(line[3])) {
            const atFlowEndMarker = indent === this.indentNext - 1 && this.flowLevel === 1 && (line[0] === "]" || line[0] === "}");
            if (!atFlowEndMarker) {
                this.flowLevel = 0;
                yield FLOW_END;
                return yield* this.parseLineStart();
            }
        }
        let n = 0;
        while(line[n] === ","){
            n += yield* this.pushCount(1);
            n += yield* this.pushSpaces(true);
            this.flowKey = false;
        }
        n += yield* this.pushIndicators();
        switch(line[n]){
            case void 0:
                return "flow";
            case "#":
                yield* this.pushCount(line.length - n);
                return "flow";
            case "{":
            case "[":
                yield* this.pushCount(1);
                this.flowKey = false;
                this.flowLevel += 1;
                return "flow";
            case "}":
            case "]":
                yield* this.pushCount(1);
                this.flowKey = true;
                this.flowLevel -= 1;
                return this.flowLevel ? "flow" : "doc";
            case "*":
                yield* this.pushUntil(isNotAnchorChar);
                return "flow";
            case '"':
            case "'":
                this.flowKey = true;
                return yield* this.parseQuotedScalar();
            case ":":
                {
                    const next = this.charAt(1);
                    if (this.flowKey || isEmpty(next) || next === ",") {
                        this.flowKey = false;
                        yield* this.pushCount(1);
                        yield* this.pushSpaces(true);
                        return "flow";
                    }
                }
            default:
                this.flowKey = false;
                return yield* this.parsePlainScalar();
        }
    }
    *parseQuotedScalar() {
        const quote = this.charAt(0);
        let end = this.buffer.indexOf(quote, this.pos + 1);
        if (quote === "'") {
            while(end !== -1 && this.buffer[end + 1] === "'")end = this.buffer.indexOf("'", end + 2);
        } else {
            while(end !== -1){
                let n = 0;
                while(this.buffer[end - 1 - n] === "\\")n += 1;
                if (n % 2 === 0) break;
                end = this.buffer.indexOf('"', end + 1);
            }
        }
        const qb = this.buffer.substring(0, end);
        let nl = qb.indexOf("\n", this.pos);
        if (nl !== -1) {
            while(nl !== -1){
                const cs = this.continueScalar(nl + 1);
                if (cs === -1) break;
                nl = qb.indexOf("\n", cs);
            }
            if (nl !== -1) {
                end = nl - (qb[nl - 1] === "\r" ? 2 : 1);
            }
        }
        if (end === -1) {
            if (!this.atEnd) return this.setNext("quoted-scalar");
            end = this.buffer.length;
        }
        yield* this.pushToIndex(end + 1, false);
        return this.flowLevel ? "flow" : "doc";
    }
    *parseBlockScalarHeader() {
        this.blockScalarIndent = -1;
        this.blockScalarKeep = false;
        let i = this.pos;
        while(true){
            const ch = this.buffer[++i];
            if (ch === "+") this.blockScalarKeep = true;
            else if (ch > "0" && ch <= "9") this.blockScalarIndent = Number(ch) - 1;
            else if (ch !== "-") break;
        }
        return yield* this.pushUntil((ch)=>isEmpty(ch) || ch === "#");
    }
    *parseBlockScalar() {
        let nl = this.pos - 1;
        let indent = 0;
        let ch;
        loop: for(let i = this.pos; ch = this.buffer[i]; ++i){
            switch(ch){
                case " ":
                    indent += 1;
                    break;
                case "\n":
                    nl = i;
                    indent = 0;
                    break;
                case "\r":
                    {
                        const next = this.buffer[i + 1];
                        if (!next && !this.atEnd) return this.setNext("block-scalar");
                        if (next === "\n") break;
                    }
                default:
                    break loop;
            }
        }
        if (!ch && !this.atEnd) return this.setNext("block-scalar");
        if (indent >= this.indentNext) {
            if (this.blockScalarIndent === -1) this.indentNext = indent;
            else this.indentNext += this.blockScalarIndent;
            do {
                const cs = this.continueScalar(nl + 1);
                if (cs === -1) break;
                nl = this.buffer.indexOf("\n", cs);
            }while (nl !== -1)
            if (nl === -1) {
                if (!this.atEnd) return this.setNext("block-scalar");
                nl = this.buffer.length;
            }
        }
        if (!this.blockScalarKeep) {
            do {
                let i = nl - 1;
                let ch2 = this.buffer[i];
                if (ch2 === "\r") ch2 = this.buffer[--i];
                const lastChar = i;
                while(ch2 === " " || ch2 === "	")ch2 = this.buffer[--i];
                if (ch2 === "\n" && i >= this.pos && i + 1 + indent > lastChar) nl = i;
                else break;
            }while (true)
        }
        yield SCALAR2;
        yield* this.pushToIndex(nl + 1, true);
        return yield* this.parseLineStart();
    }
    *parsePlainScalar() {
        const inFlow = this.flowLevel > 0;
        let end = this.pos - 1;
        let i = this.pos - 1;
        let ch;
        while(ch = this.buffer[++i]){
            if (ch === ":") {
                const next = this.buffer[i + 1];
                if (isEmpty(next) || inFlow && next === ",") break;
                end = i;
            } else if (isEmpty(ch)) {
                let next = this.buffer[i + 1];
                if (ch === "\r") {
                    if (next === "\n") {
                        i += 1;
                        ch = "\n";
                        next = this.buffer[i + 1];
                    } else end = i;
                }
                if (next === "#" || inFlow && invalidFlowScalarChars.includes(next)) break;
                if (ch === "\n") {
                    const cs = this.continueScalar(i + 1);
                    if (cs === -1) break;
                    i = Math.max(i, cs - 2);
                }
            } else {
                if (inFlow && invalidFlowScalarChars.includes(ch)) break;
                end = i;
            }
        }
        if (!ch && !this.atEnd) return this.setNext("plain-scalar");
        yield SCALAR2;
        yield* this.pushToIndex(end + 1, true);
        return inFlow ? "flow" : "doc";
    }
    *pushCount(n) {
        if (n > 0) {
            yield this.buffer.substr(this.pos, n);
            this.pos += n;
            return n;
        }
        return 0;
    }
    *pushToIndex(i, allowEmpty) {
        const s = this.buffer.slice(this.pos, i);
        if (s) {
            yield s;
            this.pos += s.length;
            return s.length;
        } else if (allowEmpty) yield "";
        return 0;
    }
    *pushIndicators() {
        switch(this.charAt(0)){
            case "!":
                return (yield* this.pushTag()) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
            case "&":
                return (yield* this.pushUntil(isNotAnchorChar)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
            case "-":
            case "?":
            case ":":
                {
                    const inFlow = this.flowLevel > 0;
                    const ch1 = this.charAt(1);
                    if (isEmpty(ch1) || inFlow && invalidFlowScalarChars.includes(ch1)) {
                        if (!inFlow) this.indentNext = this.indentValue + 1;
                        else if (this.flowKey) this.flowKey = false;
                        return (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
                    }
                }
        }
        return 0;
    }
    *pushTag() {
        if (this.charAt(1) === "<") {
            let i = this.pos + 2;
            let ch = this.buffer[i];
            while(!isEmpty(ch) && ch !== ">")ch = this.buffer[++i];
            return yield* this.pushToIndex(ch === ">" ? i + 1 : i, false);
        } else {
            let i = this.pos + 1;
            let ch = this.buffer[i];
            while(ch){
                if (tagChars.includes(ch)) ch = this.buffer[++i];
                else if (ch === "%" && hexDigits.includes(this.buffer[i + 1]) && hexDigits.includes(this.buffer[i + 2])) {
                    ch = this.buffer[i += 3];
                } else break;
            }
            return yield* this.pushToIndex(i, false);
        }
    }
    *pushNewline() {
        const ch = this.buffer[this.pos];
        if (ch === "\n") return yield* this.pushCount(1);
        else if (ch === "\r" && this.charAt(1) === "\n") return yield* this.pushCount(2);
        else return 0;
    }
    *pushSpaces(allowTabs) {
        let i = this.pos - 1;
        let ch;
        do {
            ch = this.buffer[++i];
        }while (ch === " " || allowTabs && ch === "	")
        const n = i - this.pos;
        if (n > 0) {
            yield this.buffer.substr(this.pos, n);
            this.pos = i;
        }
        return n;
    }
    *pushUntil(test) {
        let i = this.pos;
        let ch = this.buffer[i];
        while(!test(ch))ch = this.buffer[++i];
        return yield* this.pushToIndex(i, false);
    }
    constructor(){
        this.atEnd = false;
        this.blockScalarIndent = -1;
        this.blockScalarKeep = false;
        this.buffer = "";
        this.flowKey = false;
        this.flowLevel = 0;
        this.indentNext = 0;
        this.indentValue = 0;
        this.lineEndPos = null;
        this.next = null;
        this.pos = 0;
    }
};
// ../../node_modules/yaml/browser/dist/parse/line-counter.js
var LineCounter = class {
    constructor(){
        this.lineStarts = [];
        this.addNewLine = (offset)=>this.lineStarts.push(offset);
        this.linePos = (offset)=>{
            let low = 0;
            let high = this.lineStarts.length;
            while(low < high){
                const mid = low + high >> 1;
                if (this.lineStarts[mid] < offset) low = mid + 1;
                else high = mid;
            }
            if (this.lineStarts[low] === offset) return {
                line: low + 1,
                col: 1
            };
            if (low === 0) return {
                line: 0,
                col: offset
            };
            const start = this.lineStarts[low - 1];
            return {
                line: low,
                col: offset - start + 1
            };
        };
    }
};
// ../../node_modules/yaml/browser/dist/parse/parser.js
function includesToken(list, type) {
    for(let i = 0; i < list.length; ++i)if (list[i].type === type) return true;
    return false;
}
function findNonEmptyIndex(list) {
    for(let i = 0; i < list.length; ++i){
        switch(list[i].type){
            case "space":
            case "comment":
            case "newline":
                break;
            default:
                return i;
        }
    }
    return -1;
}
function isFlowToken(token) {
    switch(token == null ? void 0 : token.type){
        case "alias":
        case "scalar":
        case "single-quoted-scalar":
        case "double-quoted-scalar":
        case "flow-collection":
            return true;
        default:
            return false;
    }
}
function getPrevProps(parent) {
    var _a;
    switch(parent.type){
        case "document":
            return parent.start;
        case "block-map":
            {
                const it = parent.items[parent.items.length - 1];
                return (_a = it.sep) != null ? _a : it.start;
            }
        case "block-seq":
            return parent.items[parent.items.length - 1].start;
        default:
            return [];
    }
}
function getFirstKeyStartProps(prev) {
    var _a;
    if (prev.length === 0) return [];
    let i = prev.length;
    loop: while(--i >= 0){
        switch(prev[i].type){
            case "doc-start":
            case "explicit-key-ind":
            case "map-value-ind":
            case "seq-item-ind":
            case "newline":
                break loop;
        }
    }
    while(((_a = prev[++i]) == null ? void 0 : _a.type) === "space"){}
    return prev.splice(i, prev.length);
}
function fixFlowSeqItems(fc) {
    if (fc.start.type === "flow-seq-start") {
        for (const it of fc.items){
            if (it.sep && !it.value && !includesToken(it.start, "explicit-key-ind") && !includesToken(it.sep, "map-value-ind")) {
                if (it.key) it.value = it.key;
                delete it.key;
                if (isFlowToken(it.value)) {
                    if (it.value.end) Array.prototype.push.apply(it.value.end, it.sep);
                    else it.value.end = it.sep;
                } else Array.prototype.push.apply(it.start, it.sep);
                delete it.sep;
            }
        }
    }
}
var Parser = class {
    /**
   * Parse `source` as a YAML stream.
   * If `incomplete`, a part of the last line may be left as a buffer for the next call.
   *
   * Errors are not thrown, but yielded as `{ type: 'error', message }` tokens.
   *
   * @returns A generator of tokens representing each directive, document, and other structure.
   */ *parse(source, incomplete = false) {
        if (this.onNewLine && this.offset === 0) this.onNewLine(0);
        for (const lexeme of this.lexer.lex(source, incomplete))yield* this.next(lexeme);
        if (!incomplete) yield* this.end();
    }
    /**
   * Advance the parser by the `source` of one lexical token.
   */ *next(source) {
        this.source = source;
        if (this.atScalar) {
            this.atScalar = false;
            yield* this.step();
            this.offset += source.length;
            return;
        }
        const type = tokenType(source);
        if (!type) {
            const message = `Not a YAML token: ${source}`;
            yield* this.pop({
                type: "error",
                offset: this.offset,
                message,
                source
            });
            this.offset += source.length;
        } else if (type === "scalar") {
            this.atNewLine = false;
            this.atScalar = true;
            this.type = "scalar";
        } else {
            this.type = type;
            yield* this.step();
            switch(type){
                case "newline":
                    this.atNewLine = true;
                    this.indent = 0;
                    if (this.onNewLine) this.onNewLine(this.offset + source.length);
                    break;
                case "space":
                    if (this.atNewLine && source[0] === " ") this.indent += source.length;
                    break;
                case "explicit-key-ind":
                case "map-value-ind":
                case "seq-item-ind":
                    if (this.atNewLine) this.indent += source.length;
                    break;
                case "doc-mode":
                case "flow-error-end":
                    return;
                default:
                    this.atNewLine = false;
            }
            this.offset += source.length;
        }
    }
    /** Call at end of input to push out any remaining constructions */ *end() {
        while(this.stack.length > 0)yield* this.pop();
    }
    get sourceToken() {
        const st = {
            type: this.type,
            offset: this.offset,
            indent: this.indent,
            source: this.source
        };
        return st;
    }
    *step() {
        const top = this.peek(1);
        if (this.type === "doc-end" && (!top || top.type !== "doc-end")) {
            while(this.stack.length > 0)yield* this.pop();
            this.stack.push({
                type: "doc-end",
                offset: this.offset,
                source: this.source
            });
            return;
        }
        if (!top) return yield* this.stream();
        switch(top.type){
            case "document":
                return yield* this.document(top);
            case "alias":
            case "scalar":
            case "single-quoted-scalar":
            case "double-quoted-scalar":
                return yield* this.scalar(top);
            case "block-scalar":
                return yield* this.blockScalar(top);
            case "block-map":
                return yield* this.blockMap(top);
            case "block-seq":
                return yield* this.blockSequence(top);
            case "flow-collection":
                return yield* this.flowCollection(top);
            case "doc-end":
                return yield* this.documentEnd(top);
        }
        yield* this.pop();
    }
    peek(n) {
        return this.stack[this.stack.length - n];
    }
    *pop(error) {
        const token = error != null ? error : this.stack.pop();
        if (!token) {
            const message = "Tried to pop an empty stack";
            yield {
                type: "error",
                offset: this.offset,
                source: "",
                message
            };
        } else if (this.stack.length === 0) {
            yield token;
        } else {
            const top = this.peek(1);
            if (token.type === "block-scalar") {
                token.indent = "indent" in top ? top.indent : 0;
            } else if (token.type === "flow-collection" && top.type === "document") {
                token.indent = 0;
            }
            if (token.type === "flow-collection") fixFlowSeqItems(token);
            switch(top.type){
                case "document":
                    top.value = token;
                    break;
                case "block-scalar":
                    top.props.push(token);
                    break;
                case "block-map":
                    {
                        const it = top.items[top.items.length - 1];
                        if (it.value) {
                            top.items.push({
                                start: [],
                                key: token,
                                sep: []
                            });
                            this.onKeyLine = true;
                            return;
                        } else if (it.sep) {
                            it.value = token;
                        } else {
                            Object.assign(it, {
                                key: token,
                                sep: []
                            });
                            this.onKeyLine = !includesToken(it.start, "explicit-key-ind");
                            return;
                        }
                        break;
                    }
                case "block-seq":
                    {
                        const it = top.items[top.items.length - 1];
                        if (it.value) top.items.push({
                            start: [],
                            value: token
                        });
                        else it.value = token;
                        break;
                    }
                case "flow-collection":
                    {
                        const it = top.items[top.items.length - 1];
                        if (!it || it.value) top.items.push({
                            start: [],
                            key: token,
                            sep: []
                        });
                        else if (it.sep) it.value = token;
                        else Object.assign(it, {
                            key: token,
                            sep: []
                        });
                        return;
                    }
                default:
                    yield* this.pop();
                    yield* this.pop(token);
            }
            if ((top.type === "document" || top.type === "block-map" || top.type === "block-seq") && (token.type === "block-map" || token.type === "block-seq")) {
                const last = token.items[token.items.length - 1];
                if (last && !last.sep && !last.value && last.start.length > 0 && findNonEmptyIndex(last.start) === -1 && (token.indent === 0 || last.start.every((st)=>st.type !== "comment" || st.indent < token.indent))) {
                    if (top.type === "document") top.end = last.start;
                    else top.items.push({
                        start: last.start
                    });
                    token.items.splice(-1, 1);
                }
            }
        }
    }
    *stream() {
        switch(this.type){
            case "directive-line":
                yield {
                    type: "directive",
                    offset: this.offset,
                    source: this.source
                };
                return;
            case "byte-order-mark":
            case "space":
            case "comment":
            case "newline":
                yield this.sourceToken;
                return;
            case "doc-mode":
            case "doc-start":
                {
                    const doc = {
                        type: "document",
                        offset: this.offset,
                        start: []
                    };
                    if (this.type === "doc-start") doc.start.push(this.sourceToken);
                    this.stack.push(doc);
                    return;
                }
        }
        yield {
            type: "error",
            offset: this.offset,
            message: `Unexpected ${this.type} token in YAML stream`,
            source: this.source
        };
    }
    *document(doc) {
        if (doc.value) return yield* this.lineEnd(doc);
        switch(this.type){
            case "doc-start":
                {
                    if (findNonEmptyIndex(doc.start) !== -1) {
                        yield* this.pop();
                        yield* this.step();
                    } else doc.start.push(this.sourceToken);
                    return;
                }
            case "anchor":
            case "tag":
            case "space":
            case "comment":
            case "newline":
                doc.start.push(this.sourceToken);
                return;
        }
        const bv = this.startBlockValue(doc);
        if (bv) this.stack.push(bv);
        else {
            yield {
                type: "error",
                offset: this.offset,
                message: `Unexpected ${this.type} token in YAML document`,
                source: this.source
            };
        }
    }
    *scalar(scalar) {
        if (this.type === "map-value-ind") {
            const prev = getPrevProps(this.peek(2));
            const start = getFirstKeyStartProps(prev);
            let sep;
            if (scalar.end) {
                sep = scalar.end;
                sep.push(this.sourceToken);
                delete scalar.end;
            } else sep = [
                this.sourceToken
            ];
            const map2 = {
                type: "block-map",
                offset: scalar.offset,
                indent: scalar.indent,
                items: [
                    {
                        start,
                        key: scalar,
                        sep
                    }
                ]
            };
            this.onKeyLine = true;
            this.stack[this.stack.length - 1] = map2;
        } else yield* this.lineEnd(scalar);
    }
    *blockScalar(scalar) {
        switch(this.type){
            case "space":
            case "comment":
            case "newline":
                scalar.props.push(this.sourceToken);
                return;
            case "scalar":
                scalar.source = this.source;
                this.atNewLine = true;
                this.indent = 0;
                if (this.onNewLine) {
                    let nl = this.source.indexOf("\n") + 1;
                    while(nl !== 0){
                        this.onNewLine(this.offset + nl);
                        nl = this.source.indexOf("\n", nl) + 1;
                    }
                }
                yield* this.pop();
                break;
            default:
                yield* this.pop();
                yield* this.step();
        }
    }
    *blockMap(map2) {
        var _a;
        const it = map2.items[map2.items.length - 1];
        switch(this.type){
            case "newline":
                this.onKeyLine = false;
                if (it.value) {
                    const end = "end" in it.value ? it.value.end : void 0;
                    const last = Array.isArray(end) ? end[end.length - 1] : void 0;
                    if ((last == null ? void 0 : last.type) === "comment") end == null ? void 0 : end.push(this.sourceToken);
                    else map2.items.push({
                        start: [
                            this.sourceToken
                        ]
                    });
                } else if (it.sep) {
                    it.sep.push(this.sourceToken);
                } else {
                    it.start.push(this.sourceToken);
                }
                return;
            case "space":
            case "comment":
                if (it.value) {
                    map2.items.push({
                        start: [
                            this.sourceToken
                        ]
                    });
                } else if (it.sep) {
                    it.sep.push(this.sourceToken);
                } else {
                    if (this.atIndentedComment(it.start, map2.indent)) {
                        const prev = map2.items[map2.items.length - 2];
                        const end = (_a = prev == null ? void 0 : prev.value) == null ? void 0 : _a.end;
                        if (Array.isArray(end)) {
                            Array.prototype.push.apply(end, it.start);
                            end.push(this.sourceToken);
                            map2.items.pop();
                            return;
                        }
                    }
                    it.start.push(this.sourceToken);
                }
                return;
        }
        if (this.indent >= map2.indent) {
            const atNextItem = !this.onKeyLine && this.indent === map2.indent && it.sep;
            let start = [];
            if (atNextItem && it.sep && !it.value) {
                const nl = [];
                for(let i = 0; i < it.sep.length; ++i){
                    const st = it.sep[i];
                    switch(st.type){
                        case "newline":
                            nl.push(i);
                            break;
                        case "space":
                            break;
                        case "comment":
                            if (st.indent > map2.indent) nl.length = 0;
                            break;
                        default:
                            nl.length = 0;
                    }
                }
                if (nl.length >= 2) start = it.sep.splice(nl[1]);
            }
            switch(this.type){
                case "anchor":
                case "tag":
                    if (atNextItem || it.value) {
                        start.push(this.sourceToken);
                        map2.items.push({
                            start
                        });
                        this.onKeyLine = true;
                    } else if (it.sep) {
                        it.sep.push(this.sourceToken);
                    } else {
                        it.start.push(this.sourceToken);
                    }
                    return;
                case "explicit-key-ind":
                    if (!it.sep && !includesToken(it.start, "explicit-key-ind")) {
                        it.start.push(this.sourceToken);
                    } else if (atNextItem || it.value) {
                        start.push(this.sourceToken);
                        map2.items.push({
                            start
                        });
                    } else {
                        this.stack.push({
                            type: "block-map",
                            offset: this.offset,
                            indent: this.indent,
                            items: [
                                {
                                    start: [
                                        this.sourceToken
                                    ]
                                }
                            ]
                        });
                    }
                    this.onKeyLine = true;
                    return;
                case "map-value-ind":
                    if (includesToken(it.start, "explicit-key-ind")) {
                        if (!it.sep) {
                            if (includesToken(it.start, "newline")) {
                                Object.assign(it, {
                                    key: null,
                                    sep: [
                                        this.sourceToken
                                    ]
                                });
                            } else {
                                const start2 = getFirstKeyStartProps(it.start);
                                this.stack.push({
                                    type: "block-map",
                                    offset: this.offset,
                                    indent: this.indent,
                                    items: [
                                        {
                                            start: start2,
                                            key: null,
                                            sep: [
                                                this.sourceToken
                                            ]
                                        }
                                    ]
                                });
                            }
                        } else if (it.value) {
                            map2.items.push({
                                start: [],
                                key: null,
                                sep: [
                                    this.sourceToken
                                ]
                            });
                        } else if (includesToken(it.sep, "map-value-ind")) {
                            this.stack.push({
                                type: "block-map",
                                offset: this.offset,
                                indent: this.indent,
                                items: [
                                    {
                                        start,
                                        key: null,
                                        sep: [
                                            this.sourceToken
                                        ]
                                    }
                                ]
                            });
                        } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                            const start2 = getFirstKeyStartProps(it.start);
                            const key = it.key;
                            const sep = it.sep;
                            sep.push(this.sourceToken);
                            delete it.key, delete it.sep;
                            this.stack.push({
                                type: "block-map",
                                offset: this.offset,
                                indent: this.indent,
                                items: [
                                    {
                                        start: start2,
                                        key,
                                        sep
                                    }
                                ]
                            });
                        } else if (start.length > 0) {
                            it.sep = it.sep.concat(start, this.sourceToken);
                        } else {
                            it.sep.push(this.sourceToken);
                        }
                    } else {
                        if (!it.sep) {
                            Object.assign(it, {
                                key: null,
                                sep: [
                                    this.sourceToken
                                ]
                            });
                        } else if (it.value || atNextItem) {
                            map2.items.push({
                                start,
                                key: null,
                                sep: [
                                    this.sourceToken
                                ]
                            });
                        } else if (includesToken(it.sep, "map-value-ind")) {
                            this.stack.push({
                                type: "block-map",
                                offset: this.offset,
                                indent: this.indent,
                                items: [
                                    {
                                        start: [],
                                        key: null,
                                        sep: [
                                            this.sourceToken
                                        ]
                                    }
                                ]
                            });
                        } else {
                            it.sep.push(this.sourceToken);
                        }
                    }
                    this.onKeyLine = true;
                    return;
                case "alias":
                case "scalar":
                case "single-quoted-scalar":
                case "double-quoted-scalar":
                    {
                        const fs = this.flowScalar(this.type);
                        if (atNextItem || it.value) {
                            map2.items.push({
                                start,
                                key: fs,
                                sep: []
                            });
                            this.onKeyLine = true;
                        } else if (it.sep) {
                            this.stack.push(fs);
                        } else {
                            Object.assign(it, {
                                key: fs,
                                sep: []
                            });
                            this.onKeyLine = true;
                        }
                        return;
                    }
                default:
                    {
                        const bv = this.startBlockValue(map2);
                        if (bv) {
                            if (atNextItem && bv.type !== "block-seq" && includesToken(it.start, "explicit-key-ind")) {
                                map2.items.push({
                                    start
                                });
                            }
                            this.stack.push(bv);
                            return;
                        }
                    }
            }
        }
        yield* this.pop();
        yield* this.step();
    }
    *blockSequence(seq2) {
        var _a;
        const it = seq2.items[seq2.items.length - 1];
        switch(this.type){
            case "newline":
                if (it.value) {
                    const end = "end" in it.value ? it.value.end : void 0;
                    const last = Array.isArray(end) ? end[end.length - 1] : void 0;
                    if ((last == null ? void 0 : last.type) === "comment") end == null ? void 0 : end.push(this.sourceToken);
                    else seq2.items.push({
                        start: [
                            this.sourceToken
                        ]
                    });
                } else it.start.push(this.sourceToken);
                return;
            case "space":
            case "comment":
                if (it.value) seq2.items.push({
                    start: [
                        this.sourceToken
                    ]
                });
                else {
                    if (this.atIndentedComment(it.start, seq2.indent)) {
                        const prev = seq2.items[seq2.items.length - 2];
                        const end = (_a = prev == null ? void 0 : prev.value) == null ? void 0 : _a.end;
                        if (Array.isArray(end)) {
                            Array.prototype.push.apply(end, it.start);
                            end.push(this.sourceToken);
                            seq2.items.pop();
                            return;
                        }
                    }
                    it.start.push(this.sourceToken);
                }
                return;
            case "anchor":
            case "tag":
                if (it.value || this.indent <= seq2.indent) break;
                it.start.push(this.sourceToken);
                return;
            case "seq-item-ind":
                if (this.indent !== seq2.indent) break;
                if (it.value || includesToken(it.start, "seq-item-ind")) seq2.items.push({
                    start: [
                        this.sourceToken
                    ]
                });
                else it.start.push(this.sourceToken);
                return;
        }
        if (this.indent > seq2.indent) {
            const bv = this.startBlockValue(seq2);
            if (bv) {
                this.stack.push(bv);
                return;
            }
        }
        yield* this.pop();
        yield* this.step();
    }
    *flowCollection(fc) {
        const it = fc.items[fc.items.length - 1];
        if (this.type === "flow-error-end") {
            let top;
            do {
                yield* this.pop();
                top = this.peek(1);
            }while (top && top.type === "flow-collection")
        } else if (fc.end.length === 0) {
            switch(this.type){
                case "comma":
                case "explicit-key-ind":
                    if (!it || it.sep) fc.items.push({
                        start: [
                            this.sourceToken
                        ]
                    });
                    else it.start.push(this.sourceToken);
                    return;
                case "map-value-ind":
                    if (!it || it.value) fc.items.push({
                        start: [],
                        key: null,
                        sep: [
                            this.sourceToken
                        ]
                    });
                    else if (it.sep) it.sep.push(this.sourceToken);
                    else Object.assign(it, {
                        key: null,
                        sep: [
                            this.sourceToken
                        ]
                    });
                    return;
                case "space":
                case "comment":
                case "newline":
                case "anchor":
                case "tag":
                    if (!it || it.value) fc.items.push({
                        start: [
                            this.sourceToken
                        ]
                    });
                    else if (it.sep) it.sep.push(this.sourceToken);
                    else it.start.push(this.sourceToken);
                    return;
                case "alias":
                case "scalar":
                case "single-quoted-scalar":
                case "double-quoted-scalar":
                    {
                        const fs = this.flowScalar(this.type);
                        if (!it || it.value) fc.items.push({
                            start: [],
                            key: fs,
                            sep: []
                        });
                        else if (it.sep) this.stack.push(fs);
                        else Object.assign(it, {
                            key: fs,
                            sep: []
                        });
                        return;
                    }
                case "flow-map-end":
                case "flow-seq-end":
                    fc.end.push(this.sourceToken);
                    return;
            }
            const bv = this.startBlockValue(fc);
            if (bv) this.stack.push(bv);
            else {
                yield* this.pop();
                yield* this.step();
            }
        } else {
            const parent = this.peek(2);
            if (parent.type === "block-map" && (this.type === "map-value-ind" && parent.indent === fc.indent || this.type === "newline" && !parent.items[parent.items.length - 1].sep)) {
                yield* this.pop();
                yield* this.step();
            } else if (this.type === "map-value-ind" && parent.type !== "flow-collection") {
                const prev = getPrevProps(parent);
                const start = getFirstKeyStartProps(prev);
                fixFlowSeqItems(fc);
                const sep = fc.end.splice(1, fc.end.length);
                sep.push(this.sourceToken);
                const map2 = {
                    type: "block-map",
                    offset: fc.offset,
                    indent: fc.indent,
                    items: [
                        {
                            start,
                            key: fc,
                            sep
                        }
                    ]
                };
                this.onKeyLine = true;
                this.stack[this.stack.length - 1] = map2;
            } else {
                yield* this.lineEnd(fc);
            }
        }
    }
    flowScalar(type) {
        if (this.onNewLine) {
            let nl = this.source.indexOf("\n") + 1;
            while(nl !== 0){
                this.onNewLine(this.offset + nl);
                nl = this.source.indexOf("\n", nl) + 1;
            }
        }
        return {
            type,
            offset: this.offset,
            indent: this.indent,
            source: this.source
        };
    }
    startBlockValue(parent) {
        switch(this.type){
            case "alias":
            case "scalar":
            case "single-quoted-scalar":
            case "double-quoted-scalar":
                return this.flowScalar(this.type);
            case "block-scalar-header":
                return {
                    type: "block-scalar",
                    offset: this.offset,
                    indent: this.indent,
                    props: [
                        this.sourceToken
                    ],
                    source: ""
                };
            case "flow-map-start":
            case "flow-seq-start":
                return {
                    type: "flow-collection",
                    offset: this.offset,
                    indent: this.indent,
                    start: this.sourceToken,
                    items: [],
                    end: []
                };
            case "seq-item-ind":
                return {
                    type: "block-seq",
                    offset: this.offset,
                    indent: this.indent,
                    items: [
                        {
                            start: [
                                this.sourceToken
                            ]
                        }
                    ]
                };
            case "explicit-key-ind":
                {
                    this.onKeyLine = true;
                    const prev = getPrevProps(parent);
                    const start = getFirstKeyStartProps(prev);
                    start.push(this.sourceToken);
                    return {
                        type: "block-map",
                        offset: this.offset,
                        indent: this.indent,
                        items: [
                            {
                                start
                            }
                        ]
                    };
                }
            case "map-value-ind":
                {
                    this.onKeyLine = true;
                    const prev = getPrevProps(parent);
                    const start = getFirstKeyStartProps(prev);
                    return {
                        type: "block-map",
                        offset: this.offset,
                        indent: this.indent,
                        items: [
                            {
                                start,
                                key: null,
                                sep: [
                                    this.sourceToken
                                ]
                            }
                        ]
                    };
                }
        }
        return null;
    }
    atIndentedComment(start, indent) {
        if (this.type !== "comment") return false;
        if (this.indent <= indent) return false;
        return start.every((st)=>st.type === "newline" || st.type === "space");
    }
    *documentEnd(docEnd) {
        if (this.type !== "doc-mode") {
            if (docEnd.end) docEnd.end.push(this.sourceToken);
            else docEnd.end = [
                this.sourceToken
            ];
            if (this.type === "newline") yield* this.pop();
        }
    }
    *lineEnd(token) {
        switch(this.type){
            case "comma":
            case "doc-start":
            case "doc-end":
            case "flow-seq-end":
            case "flow-map-end":
            case "map-value-ind":
                yield* this.pop();
                yield* this.step();
                break;
            case "newline":
                this.onKeyLine = false;
            case "space":
            case "comment":
            default:
                if (token.end) token.end.push(this.sourceToken);
                else token.end = [
                    this.sourceToken
                ];
                if (this.type === "newline") yield* this.pop();
        }
    }
    /**
   * @param onNewLine - If defined, called separately with the start position of
   *   each new line (in `parse()`, including the start of input).
   */ constructor(onNewLine){
        this.atNewLine = true;
        this.atScalar = false;
        this.indent = 0;
        this.offset = 0;
        this.onKeyLine = false;
        this.stack = [];
        this.source = "";
        this.type = "";
        this.lexer = new Lexer();
        this.onNewLine = onNewLine;
    }
};
// ../../node_modules/yaml/browser/dist/public-api.js
function parseOptions(options) {
    const prettyErrors = options.prettyErrors !== false;
    const lineCounter = options.lineCounter || prettyErrors && new LineCounter() || null;
    return {
        lineCounter,
        prettyErrors
    };
}
function parseDocument(source, options = {}) {
    const { lineCounter, prettyErrors } = parseOptions(options);
    const parser2 = new Parser(lineCounter == null ? void 0 : lineCounter.addNewLine);
    const composer = new Composer(options);
    let doc = null;
    for (const _doc of composer.compose(parser2.parse(source), true, source.length)){
        if (!doc) doc = _doc;
        else if (doc.options.logLevel !== "silent") {
            doc.errors.push(new YAMLParseError(_doc.range.slice(0, 2), "MULTIPLE_DOCS", "Source contains multiple documents; please use YAML.parseAllDocuments()"));
            break;
        }
    }
    if (prettyErrors && lineCounter) {
        doc.errors.forEach(prettifyError(source, lineCounter));
        doc.warnings.forEach(prettifyError(source, lineCounter));
    }
    return doc;
}
function parse3(src, reviver, options) {
    let _reviver = void 0;
    if (typeof reviver === "function") {
        _reviver = reviver;
    } else if (options === void 0 && reviver && typeof reviver === "object") {
        options = reviver;
    }
    const doc = parseDocument(src, options);
    if (!doc) return null;
    doc.warnings.forEach((warning)=>warn(doc.options.logLevel, warning));
    if (doc.errors.length > 0) {
        if (doc.options.logLevel !== "silent") throw doc.errors[0];
        else doc.errors = [];
    }
    return doc.toJS(Object.assign({
        reviver: _reviver
    }, options));
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlSchemaService.js
var path2 = __toESM(require_path_browserify());
// ../../node_modules/yaml-language-server/lib/esm/languageservice/utils/objects.js
function equals2(one, other) {
    if (one === other) {
        return true;
    }
    if (one === null || one === void 0 || other === null || other === void 0) {
        return false;
    }
    if (typeof one !== typeof other) {
        return false;
    }
    if (typeof one !== "object") {
        return false;
    }
    if (Array.isArray(one) !== Array.isArray(other)) {
        return false;
    }
    let i, key;
    if (Array.isArray(one)) {
        if (one.length !== other.length) {
            return false;
        }
        for(i = 0; i < one.length; i++){
            if (!equals2(one[i], other[i])) {
                return false;
            }
        }
    } else {
        const oneKeys = [];
        for(key in one){
            oneKeys.push(key);
        }
        oneKeys.sort();
        const otherKeys = [];
        for(key in other){
            otherKeys.push(key);
        }
        otherKeys.sort();
        if (!equals2(oneKeys, otherKeys)) {
            return false;
        }
        for(i = 0; i < oneKeys.length; i++){
            if (!equals2(one[oneKeys[i]], other[oneKeys[i]])) {
                return false;
            }
        }
    }
    return true;
}
function isNumber2(val) {
    return typeof val === "number";
}
function isDefined2(val) {
    return typeof val !== "undefined";
}
function isBoolean2(val) {
    return typeof val === "boolean";
}
function isString2(val) {
    return typeof val === "string";
}
function isIterable(val) {
    return Symbol.iterator in Object(val);
}
function convertErrorToTelemetryMsg(err) {
    var _a;
    if (!err) return "null";
    if (err instanceof Error) {
        return (_a = err.stack) != null ? _a : err.toString();
    }
    return err.toString();
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/utils/schemaUtils.js
var path = __toESM(require_path_browserify());
function getSchemaTypeName(schema4) {
    const closestTitleWithType = schema4.type && schema4.closestTitle;
    if (schema4.title) {
        return schema4.title;
    }
    if (schema4.$id) {
        return getSchemaRefTypeTitle(schema4.$id);
    }
    if (schema4.$ref || schema4._$ref) {
        return getSchemaRefTypeTitle(schema4.$ref || schema4._$ref);
    }
    return Array.isArray(schema4.type) ? schema4.type.join(" | ") : closestTitleWithType ? schema4.type.concat("(", schema4.closestTitle, ")") : schema4.type || schema4.closestTitle;
}
function getSchemaRefTypeTitle($ref) {
    const match = $ref.match(/^(?:.*\/)?(.*?)(?:\.schema\.json)?$/);
    let type = !!match && match[1];
    if (!type) {
        type = "typeNotFound";
        console.error(`$ref (${$ref}) not parsed properly`);
    }
    return type;
}
function getSchemaTitle(schema4, url) {
    const uri = yaml_service_URI.parse(url);
    let baseName = path.basename(uri.fsPath);
    if (!path.extname(uri.fsPath)) {
        baseName += ".json";
    }
    if (Object.getOwnPropertyDescriptor(schema4, "name")) {
        return Object.getOwnPropertyDescriptor(schema4, "name").value + ` (${baseName})`;
    } else if (schema4.title) {
        return schema4.description ? schema4.title + " - " + schema4.description + ` (${baseName})` : schema4.title + ` (${baseName})`;
    }
    return baseName;
}
function isPrimitiveType(schema4) {
    return schema4.type !== "object" && !isAnyOfAllOfOneOfType(schema4);
}
function isAnyOfAllOfOneOfType(schema4) {
    return !!(schema4.anyOf || schema4.allOf || schema4.oneOf);
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/utils/json.js
function stringifyObject(obj, indent, stringifyLiteral) {
    if (obj !== null && typeof obj === "object") {
        var newIndent = indent + "	";
        if (Array.isArray(obj)) {
            if (obj.length === 0) {
                return "[]";
            }
            var result = "[\n";
            for(var i = 0; i < obj.length; i++){
                result += newIndent + stringifyObject(obj[i], newIndent, stringifyLiteral);
                if (i < obj.length - 1) {
                    result += ",";
                }
                result += "\n";
            }
            result += indent + "]";
            return result;
        } else {
            var keys = Object.keys(obj);
            if (keys.length === 0) {
                return "{}";
            }
            var result = "{\n";
            for(var i = 0; i < keys.length; i++){
                var key = keys[i];
                result += newIndent + JSON.stringify(key) + ": " + stringifyObject(obj[key], newIndent, stringifyLiteral);
                if (i < keys.length - 1) {
                    result += ",";
                }
                result += "\n";
            }
            result += indent + "}";
            return result;
        }
    }
    return stringifyLiteral(obj);
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/services/jsonCompletion.js
var localize4 = loadMessageBundle();
var valueCommitCharacters = [
    ",",
    "}",
    "]"
];
var propertyCommitCharacters = [
    ":"
];
var JSONCompletion = /** @class */ function() {
    function JSONCompletion2(schemaService, contributions, promiseConstructor, clientCapabilities) {
        if (contributions === void 0) {
            contributions = [];
        }
        if (promiseConstructor === void 0) {
            promiseConstructor = Promise;
        }
        if (clientCapabilities === void 0) {
            clientCapabilities = {};
        }
        this.schemaService = schemaService;
        this.contributions = contributions;
        this.promiseConstructor = promiseConstructor;
        this.clientCapabilities = clientCapabilities;
    }
    JSONCompletion2.prototype.doResolve = function(item) {
        for(var i = this.contributions.length - 1; i >= 0; i--){
            var resolveCompletion = this.contributions[i].resolveCompletion;
            if (resolveCompletion) {
                var resolver = resolveCompletion(item);
                if (resolver) {
                    return resolver;
                }
            }
        }
        return this.promiseConstructor.resolve(item);
    };
    JSONCompletion2.prototype.doComplete = function(document2, position, doc) {
        var _this = this;
        var result = {
            items: [],
            isIncomplete: false
        };
        var text = document2.getText();
        var offset = document2.offsetAt(position);
        var node = doc.getNodeFromOffset(offset, true);
        if (this.isInComment(document2, node ? node.offset : 0, offset)) {
            return Promise.resolve(result);
        }
        if (node && offset === node.offset + node.length && offset > 0) {
            var ch = text[offset - 1];
            if (node.type === "object" && ch === "}" || node.type === "array" && ch === "]") {
                node = node.parent;
            }
        }
        var currentWord = this.getCurrentWord(document2, offset);
        var overwriteRange;
        if (node && (node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null")) {
            overwriteRange = import_vscode_languageserver_types.Range.create(document2.positionAt(node.offset), document2.positionAt(node.offset + node.length));
        } else {
            var overwriteStart = offset - currentWord.length;
            if (overwriteStart > 0 && text[overwriteStart - 1] === '"') {
                overwriteStart--;
            }
            overwriteRange = import_vscode_languageserver_types.Range.create(document2.positionAt(overwriteStart), position);
        }
        var supportsCommitCharacters = false;
        var proposed = {};
        var collector = {
            add: function(suggestion) {
                var label = suggestion.label;
                var existing = proposed[label];
                if (!existing) {
                    label = label.replace(/[\n]/g, "\u21B5");
                    if (label.length > 60) {
                        var shortendedLabel = label.substr(0, 57).trim() + "...";
                        if (!proposed[shortendedLabel]) {
                            label = shortendedLabel;
                        }
                    }
                    if (overwriteRange && suggestion.insertText !== void 0) {
                        suggestion.textEdit = import_vscode_languageserver_types.TextEdit.replace(overwriteRange, suggestion.insertText);
                    }
                    if (supportsCommitCharacters) {
                        suggestion.commitCharacters = suggestion.kind === import_vscode_languageserver_types.CompletionItemKind.Property ? propertyCommitCharacters : valueCommitCharacters;
                    }
                    suggestion.label = label;
                    proposed[label] = suggestion;
                    result.items.push(suggestion);
                } else {
                    if (!existing.documentation) {
                        existing.documentation = suggestion.documentation;
                    }
                    if (!existing.detail) {
                        existing.detail = suggestion.detail;
                    }
                }
            },
            setAsIncomplete: function() {
                result.isIncomplete = true;
            },
            error: function(message) {
                console.error(message);
            },
            log: function(message) {
                console.log(message);
            },
            getNumberOfProposals: function() {
                return result.items.length;
            }
        };
        return this.schemaService.getSchemaForResource(document2.uri, doc).then(function(schema4) {
            var collectionPromises = [];
            var addValue = true;
            var currentKey = "";
            var currentProperty = void 0;
            if (node) {
                if (node.type === "string") {
                    var parent = node.parent;
                    if (parent && parent.type === "property" && parent.keyNode === node) {
                        addValue = !parent.valueNode;
                        currentProperty = parent;
                        currentKey = text.substr(node.offset + 1, node.length - 2);
                        if (parent) {
                            node = parent.parent;
                        }
                    }
                }
            }
            if (node && node.type === "object") {
                if (node.offset === offset) {
                    return result;
                }
                var properties = node.properties;
                properties.forEach(function(p) {
                    if (!currentProperty || currentProperty !== p) {
                        proposed[p.keyNode.value] = import_vscode_languageserver_types.CompletionItem.create("__");
                    }
                });
                var separatorAfter_1 = "";
                if (addValue) {
                    separatorAfter_1 = _this.evaluateSeparatorAfter(document2, document2.offsetAt(overwriteRange.end));
                }
                if (schema4) {
                    _this.getPropertyCompletions(schema4, doc, node, addValue, separatorAfter_1, collector);
                } else {
                    _this.getSchemaLessPropertyCompletions(doc, node, currentKey, collector);
                }
                var location_1 = getNodePath3(node);
                _this.contributions.forEach(function(contribution) {
                    var collectPromise = contribution.collectPropertyCompletions(document2.uri, location_1, currentWord, addValue, separatorAfter_1 === "", collector);
                    if (collectPromise) {
                        collectionPromises.push(collectPromise);
                    }
                });
                if (!schema4 && currentWord.length > 0 && text.charAt(offset - currentWord.length - 1) !== '"') {
                    collector.add({
                        kind: import_vscode_languageserver_types.CompletionItemKind.Property,
                        label: _this.getLabelForValue(currentWord),
                        insertText: _this.getInsertTextForProperty(currentWord, void 0, false, separatorAfter_1),
                        insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                        documentation: ""
                    });
                    collector.setAsIncomplete();
                }
            }
            var types = {};
            if (schema4) {
                _this.getValueCompletions(schema4, doc, node, offset, document2, collector, types);
            } else {
                _this.getSchemaLessValueCompletions(doc, node, offset, document2, collector);
            }
            if (_this.contributions.length > 0) {
                _this.getContributedValueCompletions(doc, node, offset, document2, collector, collectionPromises);
            }
            return _this.promiseConstructor.all(collectionPromises).then(function() {
                if (collector.getNumberOfProposals() === 0) {
                    var offsetForSeparator = offset;
                    if (node && (node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null")) {
                        offsetForSeparator = node.offset + node.length;
                    }
                    var separatorAfter = _this.evaluateSeparatorAfter(document2, offsetForSeparator);
                    _this.addFillerValueCompletions(types, separatorAfter, collector);
                }
                return result;
            });
        });
    };
    JSONCompletion2.prototype.getPropertyCompletions = function(schema4, doc, node, addValue, separatorAfter, collector) {
        var _this = this;
        var matchingSchemas = doc.getMatchingSchemas(schema4.schema, node.offset);
        matchingSchemas.forEach(function(s) {
            if (s.node === node && !s.inverted) {
                var schemaProperties_1 = s.schema.properties;
                if (schemaProperties_1) {
                    Object.keys(schemaProperties_1).forEach(function(key) {
                        var propertySchema = schemaProperties_1[key];
                        if (typeof propertySchema === "object" && !propertySchema.deprecationMessage && !propertySchema.doNotSuggest) {
                            var proposal = {
                                kind: import_vscode_languageserver_types.CompletionItemKind.Property,
                                label: key,
                                insertText: _this.getInsertTextForProperty(key, propertySchema, addValue, separatorAfter),
                                insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                                filterText: _this.getFilterTextForValue(key),
                                documentation: _this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || ""
                            };
                            if (propertySchema.suggestSortText !== void 0) {
                                proposal.sortText = propertySchema.suggestSortText;
                            }
                            if (proposal.insertText && endsWith(proposal.insertText, "$1" + separatorAfter)) {
                                proposal.command = {
                                    title: "Suggest",
                                    command: "editor.action.triggerSuggest"
                                };
                            }
                            collector.add(proposal);
                        }
                    });
                }
                var schemaPropertyNames_1 = s.schema.propertyNames;
                if (typeof schemaPropertyNames_1 === "object" && !schemaPropertyNames_1.deprecationMessage && !schemaPropertyNames_1.doNotSuggest) {
                    var propertyNameCompletionItem = function(name, enumDescription2) {
                        if (enumDescription2 === void 0) {
                            enumDescription2 = void 0;
                        }
                        var proposal = {
                            kind: import_vscode_languageserver_types.CompletionItemKind.Property,
                            label: name,
                            insertText: _this.getInsertTextForProperty(name, void 0, addValue, separatorAfter),
                            insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                            filterText: _this.getFilterTextForValue(name),
                            documentation: enumDescription2 || _this.fromMarkup(schemaPropertyNames_1.markdownDescription) || schemaPropertyNames_1.description || ""
                        };
                        if (schemaPropertyNames_1.suggestSortText !== void 0) {
                            proposal.sortText = schemaPropertyNames_1.suggestSortText;
                        }
                        if (proposal.insertText && endsWith(proposal.insertText, "$1" + separatorAfter)) {
                            proposal.command = {
                                title: "Suggest",
                                command: "editor.action.triggerSuggest"
                            };
                        }
                        collector.add(proposal);
                    };
                    if (schemaPropertyNames_1.enum) {
                        for(var i = 0; i < schemaPropertyNames_1.enum.length; i++){
                            var enumDescription = void 0;
                            if (schemaPropertyNames_1.markdownEnumDescriptions && i < schemaPropertyNames_1.markdownEnumDescriptions.length) {
                                enumDescription = _this.fromMarkup(schemaPropertyNames_1.markdownEnumDescriptions[i]);
                            } else if (schemaPropertyNames_1.enumDescriptions && i < schemaPropertyNames_1.enumDescriptions.length) {
                                enumDescription = schemaPropertyNames_1.enumDescriptions[i];
                            }
                            propertyNameCompletionItem(schemaPropertyNames_1.enum[i], enumDescription);
                        }
                    }
                    if (schemaPropertyNames_1.const) {
                        propertyNameCompletionItem(schemaPropertyNames_1.const);
                    }
                }
            }
        });
    };
    JSONCompletion2.prototype.getSchemaLessPropertyCompletions = function(doc, node, currentKey, collector) {
        var _this = this;
        var collectCompletionsForSimilarObject = function(obj) {
            obj.properties.forEach(function(p) {
                var key = p.keyNode.value;
                collector.add({
                    kind: import_vscode_languageserver_types.CompletionItemKind.Property,
                    label: key,
                    insertText: _this.getInsertTextForValue(key, ""),
                    insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                    filterText: _this.getFilterTextForValue(key),
                    documentation: ""
                });
            });
        };
        if (node.parent) {
            if (node.parent.type === "property") {
                var parentKey_1 = node.parent.keyNode.value;
                doc.visit(function(n) {
                    if (n.type === "property" && n !== node.parent && n.keyNode.value === parentKey_1 && n.valueNode && n.valueNode.type === "object") {
                        collectCompletionsForSimilarObject(n.valueNode);
                    }
                    return true;
                });
            } else if (node.parent.type === "array") {
                node.parent.items.forEach(function(n) {
                    if (n.type === "object" && n !== node) {
                        collectCompletionsForSimilarObject(n);
                    }
                });
            }
        } else if (node.type === "object") {
            collector.add({
                kind: import_vscode_languageserver_types.CompletionItemKind.Property,
                label: "$schema",
                insertText: this.getInsertTextForProperty("$schema", void 0, true, ""),
                insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                documentation: "",
                filterText: this.getFilterTextForValue("$schema")
            });
        }
    };
    JSONCompletion2.prototype.getSchemaLessValueCompletions = function(doc, node, offset, document2, collector) {
        var _this = this;
        var offsetForSeparator = offset;
        if (node && (node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null")) {
            offsetForSeparator = node.offset + node.length;
            node = node.parent;
        }
        if (!node) {
            collector.add({
                kind: this.getSuggestionKind("object"),
                label: "Empty object",
                insertText: this.getInsertTextForValue({}, ""),
                insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                documentation: ""
            });
            collector.add({
                kind: this.getSuggestionKind("array"),
                label: "Empty array",
                insertText: this.getInsertTextForValue([], ""),
                insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                documentation: ""
            });
            return;
        }
        var separatorAfter = this.evaluateSeparatorAfter(document2, offsetForSeparator);
        var collectSuggestionsForValues = function(value1) {
            if (value1.parent && !contains2(value1.parent, offset, true)) {
                collector.add({
                    kind: _this.getSuggestionKind(value1.type),
                    label: _this.getLabelTextForMatchingNode(value1, document2),
                    insertText: _this.getInsertTextForMatchingNode(value1, document2, separatorAfter),
                    insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                    documentation: ""
                });
            }
            if (value1.type === "boolean") {
                _this.addBooleanValueCompletion(!value1.value, separatorAfter, collector);
            }
        };
        if (node.type === "property") {
            if (offset > (node.colonOffset || 0)) {
                var valueNode = node.valueNode;
                if (valueNode && (offset > valueNode.offset + valueNode.length || valueNode.type === "object" || valueNode.type === "array")) {
                    return;
                }
                var parentKey_2 = node.keyNode.value;
                doc.visit(function(n) {
                    if (n.type === "property" && n.keyNode.value === parentKey_2 && n.valueNode) {
                        collectSuggestionsForValues(n.valueNode);
                    }
                    return true;
                });
                if (parentKey_2 === "$schema" && node.parent && !node.parent.parent) {
                    this.addDollarSchemaCompletions(separatorAfter, collector);
                }
            }
        }
        if (node.type === "array") {
            if (node.parent && node.parent.type === "property") {
                var parentKey_3 = node.parent.keyNode.value;
                doc.visit(function(n) {
                    if (n.type === "property" && n.keyNode.value === parentKey_3 && n.valueNode && n.valueNode.type === "array") {
                        n.valueNode.items.forEach(collectSuggestionsForValues);
                    }
                    return true;
                });
            } else {
                node.items.forEach(collectSuggestionsForValues);
            }
        }
    };
    JSONCompletion2.prototype.getValueCompletions = function(schema4, doc, node, offset, document2, collector, types) {
        var offsetForSeparator = offset;
        var parentKey = void 0;
        var valueNode = void 0;
        if (node && (node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null")) {
            offsetForSeparator = node.offset + node.length;
            valueNode = node;
            node = node.parent;
        }
        if (!node) {
            this.addSchemaValueCompletions(schema4.schema, "", collector, types);
            return;
        }
        if (node.type === "property" && offset > (node.colonOffset || 0)) {
            var valueNode_1 = node.valueNode;
            if (valueNode_1 && offset > valueNode_1.offset + valueNode_1.length) {
                return;
            }
            parentKey = node.keyNode.value;
            node = node.parent;
        }
        if (node && (parentKey !== void 0 || node.type === "array")) {
            var separatorAfter = this.evaluateSeparatorAfter(document2, offsetForSeparator);
            var matchingSchemas = doc.getMatchingSchemas(schema4.schema, node.offset, valueNode);
            for(var _i = 0, matchingSchemas_1 = matchingSchemas; _i < matchingSchemas_1.length; _i++){
                var s = matchingSchemas_1[_i];
                if (s.node === node && !s.inverted && s.schema) {
                    if (node.type === "array" && s.schema.items) {
                        if (Array.isArray(s.schema.items)) {
                            var index = this.findItemAtOffset(node, document2, offset);
                            if (index < s.schema.items.length) {
                                this.addSchemaValueCompletions(s.schema.items[index], separatorAfter, collector, types);
                            }
                        } else {
                            this.addSchemaValueCompletions(s.schema.items, separatorAfter, collector, types);
                        }
                    }
                    if (parentKey !== void 0) {
                        var propertyMatched = false;
                        if (s.schema.properties) {
                            var propertySchema = s.schema.properties[parentKey];
                            if (propertySchema) {
                                propertyMatched = true;
                                this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types);
                            }
                        }
                        if (s.schema.patternProperties && !propertyMatched) {
                            for(var _a = 0, _b = Object.keys(s.schema.patternProperties); _a < _b.length; _a++){
                                var pattern = _b[_a];
                                var regex = extendedRegExp(pattern);
                                if (regex.test(parentKey)) {
                                    propertyMatched = true;
                                    var propertySchema = s.schema.patternProperties[pattern];
                                    this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types);
                                }
                            }
                        }
                        if (s.schema.additionalProperties && !propertyMatched) {
                            var propertySchema = s.schema.additionalProperties;
                            this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types);
                        }
                    }
                }
            }
            if (parentKey === "$schema" && !node.parent) {
                this.addDollarSchemaCompletions(separatorAfter, collector);
            }
            if (types["boolean"]) {
                this.addBooleanValueCompletion(true, separatorAfter, collector);
                this.addBooleanValueCompletion(false, separatorAfter, collector);
            }
            if (types["null"]) {
                this.addNullValueCompletion(separatorAfter, collector);
            }
        }
    };
    JSONCompletion2.prototype.getContributedValueCompletions = function(doc, node, offset, document2, collector, collectionPromises) {
        if (!node) {
            this.contributions.forEach(function(contribution) {
                var collectPromise = contribution.collectDefaultCompletions(document2.uri, collector);
                if (collectPromise) {
                    collectionPromises.push(collectPromise);
                }
            });
        } else {
            if (node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null") {
                node = node.parent;
            }
            if (node && node.type === "property" && offset > (node.colonOffset || 0)) {
                var parentKey_4 = node.keyNode.value;
                var valueNode = node.valueNode;
                if ((!valueNode || offset <= valueNode.offset + valueNode.length) && node.parent) {
                    var location_2 = getNodePath3(node.parent);
                    this.contributions.forEach(function(contribution) {
                        var collectPromise = contribution.collectValueCompletions(document2.uri, location_2, parentKey_4, collector);
                        if (collectPromise) {
                            collectionPromises.push(collectPromise);
                        }
                    });
                }
            }
        }
    };
    JSONCompletion2.prototype.addSchemaValueCompletions = function(schema4, separatorAfter, collector, types) {
        var _this = this;
        if (typeof schema4 === "object") {
            this.addEnumValueCompletions(schema4, separatorAfter, collector);
            this.addDefaultValueCompletions(schema4, separatorAfter, collector);
            this.collectTypes(schema4, types);
            if (Array.isArray(schema4.allOf)) {
                schema4.allOf.forEach(function(s) {
                    return _this.addSchemaValueCompletions(s, separatorAfter, collector, types);
                });
            }
            if (Array.isArray(schema4.anyOf)) {
                schema4.anyOf.forEach(function(s) {
                    return _this.addSchemaValueCompletions(s, separatorAfter, collector, types);
                });
            }
            if (Array.isArray(schema4.oneOf)) {
                schema4.oneOf.forEach(function(s) {
                    return _this.addSchemaValueCompletions(s, separatorAfter, collector, types);
                });
            }
        }
    };
    JSONCompletion2.prototype.addDefaultValueCompletions = function(schema4, separatorAfter, collector, arrayDepth) {
        var _this = this;
        if (arrayDepth === void 0) {
            arrayDepth = 0;
        }
        var hasProposals = false;
        if (isDefined(schema4.default)) {
            var type = schema4.type;
            var value1 = schema4.default;
            for(var i = arrayDepth; i > 0; i--){
                value1 = [
                    value1
                ];
                type = "array";
            }
            collector.add({
                kind: this.getSuggestionKind(type),
                label: this.getLabelForValue(value1),
                insertText: this.getInsertTextForValue(value1, separatorAfter),
                insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                detail: localize4("json.suggest.default", "Default value")
            });
            hasProposals = true;
        }
        if (Array.isArray(schema4.examples)) {
            schema4.examples.forEach(function(example) {
                var type2 = schema4.type;
                var value2 = example;
                for(var i2 = arrayDepth; i2 > 0; i2--){
                    value2 = [
                        value2
                    ];
                    type2 = "array";
                }
                collector.add({
                    kind: _this.getSuggestionKind(type2),
                    label: _this.getLabelForValue(value2),
                    insertText: _this.getInsertTextForValue(value2, separatorAfter),
                    insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet
                });
                hasProposals = true;
            });
        }
        if (Array.isArray(schema4.defaultSnippets)) {
            schema4.defaultSnippets.forEach(function(s) {
                var type2 = schema4.type;
                var value2 = s.body;
                var label = s.label;
                var insertText;
                var filterText;
                if (isDefined(value2)) {
                    var type_1 = schema4.type;
                    for(var i2 = arrayDepth; i2 > 0; i2--){
                        value2 = [
                            value2
                        ];
                        type_1 = "array";
                    }
                    insertText = _this.getInsertTextForSnippetValue(value2, separatorAfter);
                    filterText = _this.getFilterTextForSnippetValue(value2);
                    label = label || _this.getLabelForSnippetValue(value2);
                } else if (typeof s.bodyText === "string") {
                    var prefix = "", suffix = "", indent = "";
                    for(var i2 = arrayDepth; i2 > 0; i2--){
                        prefix = prefix + indent + "[\n";
                        suffix = suffix + "\n" + indent + "]";
                        indent += "	";
                        type2 = "array";
                    }
                    insertText = prefix + indent + s.bodyText.split("\n").join("\n" + indent) + suffix + separatorAfter;
                    label = label || insertText, filterText = insertText.replace(/[\n]/g, "");
                } else {
                    return;
                }
                collector.add({
                    kind: _this.getSuggestionKind(type2),
                    label,
                    documentation: _this.fromMarkup(s.markdownDescription) || s.description,
                    insertText,
                    insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                    filterText
                });
                hasProposals = true;
            });
        }
        if (!hasProposals && typeof schema4.items === "object" && !Array.isArray(schema4.items) && arrayDepth < 5) {
            this.addDefaultValueCompletions(schema4.items, separatorAfter, collector, arrayDepth + 1);
        }
    };
    JSONCompletion2.prototype.addEnumValueCompletions = function(schema4, separatorAfter, collector) {
        if (isDefined(schema4.const)) {
            collector.add({
                kind: this.getSuggestionKind(schema4.type),
                label: this.getLabelForValue(schema4.const),
                insertText: this.getInsertTextForValue(schema4.const, separatorAfter),
                insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                documentation: this.fromMarkup(schema4.markdownDescription) || schema4.description
            });
        }
        if (Array.isArray(schema4.enum)) {
            for(var i = 0, length = schema4.enum.length; i < length; i++){
                var enm = schema4.enum[i];
                var documentation = this.fromMarkup(schema4.markdownDescription) || schema4.description;
                if (schema4.markdownEnumDescriptions && i < schema4.markdownEnumDescriptions.length && this.doesSupportMarkdown()) {
                    documentation = this.fromMarkup(schema4.markdownEnumDescriptions[i]);
                } else if (schema4.enumDescriptions && i < schema4.enumDescriptions.length) {
                    documentation = schema4.enumDescriptions[i];
                }
                collector.add({
                    kind: this.getSuggestionKind(schema4.type),
                    label: this.getLabelForValue(enm),
                    insertText: this.getInsertTextForValue(enm, separatorAfter),
                    insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                    documentation
                });
            }
        }
    };
    JSONCompletion2.prototype.collectTypes = function(schema4, types) {
        if (Array.isArray(schema4.enum) || isDefined(schema4.const)) {
            return;
        }
        var type = schema4.type;
        if (Array.isArray(type)) {
            type.forEach(function(t1) {
                return types[t1] = true;
            });
        } else if (type) {
            types[type] = true;
        }
    };
    JSONCompletion2.prototype.addFillerValueCompletions = function(types, separatorAfter, collector) {
        if (types["object"]) {
            collector.add({
                kind: this.getSuggestionKind("object"),
                label: "{}",
                insertText: this.getInsertTextForGuessedValue({}, separatorAfter),
                insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                detail: localize4("defaults.object", "New object"),
                documentation: ""
            });
        }
        if (types["array"]) {
            collector.add({
                kind: this.getSuggestionKind("array"),
                label: "[]",
                insertText: this.getInsertTextForGuessedValue([], separatorAfter),
                insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                detail: localize4("defaults.array", "New array"),
                documentation: ""
            });
        }
    };
    JSONCompletion2.prototype.addBooleanValueCompletion = function(value1, separatorAfter, collector) {
        collector.add({
            kind: this.getSuggestionKind("boolean"),
            label: value1 ? "true" : "false",
            insertText: this.getInsertTextForValue(value1, separatorAfter),
            insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
            documentation: ""
        });
    };
    JSONCompletion2.prototype.addNullValueCompletion = function(separatorAfter, collector) {
        collector.add({
            kind: this.getSuggestionKind("null"),
            label: "null",
            insertText: "null" + separatorAfter,
            insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
            documentation: ""
        });
    };
    JSONCompletion2.prototype.addDollarSchemaCompletions = function(separatorAfter, collector) {
        var _this = this;
        var schemaIds = this.schemaService.getRegisteredSchemaIds(function(schema4) {
            return schema4 === "http" || schema4 === "https";
        });
        schemaIds.forEach(function(schemaId) {
            return collector.add({
                kind: import_vscode_languageserver_types.CompletionItemKind.Module,
                label: _this.getLabelForValue(schemaId),
                filterText: _this.getFilterTextForValue(schemaId),
                insertText: _this.getInsertTextForValue(schemaId, separatorAfter),
                insertTextFormat: import_vscode_languageserver_types.InsertTextFormat.Snippet,
                documentation: ""
            });
        });
    };
    JSONCompletion2.prototype.getLabelForValue = function(value1) {
        return JSON.stringify(value1);
    };
    JSONCompletion2.prototype.getFilterTextForValue = function(value1) {
        return JSON.stringify(value1);
    };
    JSONCompletion2.prototype.getFilterTextForSnippetValue = function(value1) {
        return JSON.stringify(value1).replace(/\$\{\d+:([^}]+)\}|\$\d+/g, "$1");
    };
    JSONCompletion2.prototype.getLabelForSnippetValue = function(value1) {
        var label = JSON.stringify(value1);
        return label.replace(/\$\{\d+:([^}]+)\}|\$\d+/g, "$1");
    };
    JSONCompletion2.prototype.getInsertTextForPlainText = function(text) {
        return text.replace(/[\\\$\}]/g, "\\$&");
    };
    JSONCompletion2.prototype.getInsertTextForValue = function(value1, separatorAfter) {
        var text = JSON.stringify(value1, null, "	");
        if (text === "{}") {
            return "{$1}" + separatorAfter;
        } else if (text === "[]") {
            return "[$1]" + separatorAfter;
        }
        return this.getInsertTextForPlainText(text + separatorAfter);
    };
    JSONCompletion2.prototype.getInsertTextForSnippetValue = function(value1, separatorAfter) {
        var replacer = function(value2) {
            if (typeof value2 === "string") {
                if (value2[0] === "^") {
                    return value2.substr(1);
                }
            }
            return JSON.stringify(value2);
        };
        return stringifyObject(value1, "", replacer) + separatorAfter;
    };
    JSONCompletion2.prototype.getInsertTextForGuessedValue = function(value1, separatorAfter) {
        switch(typeof value1){
            case "object":
                if (value1 === null) {
                    return "${1:null}" + separatorAfter;
                }
                return this.getInsertTextForValue(value1, separatorAfter);
            case "string":
                var snippetValue = JSON.stringify(value1);
                snippetValue = snippetValue.substr(1, snippetValue.length - 2);
                snippetValue = this.getInsertTextForPlainText(snippetValue);
                return '"${1:' + snippetValue + '}"' + separatorAfter;
            case "number":
            case "boolean":
                return "${1:" + JSON.stringify(value1) + "}" + separatorAfter;
        }
        return this.getInsertTextForValue(value1, separatorAfter);
    };
    JSONCompletion2.prototype.getSuggestionKind = function(type) {
        if (Array.isArray(type)) {
            var array = type;
            type = array.length > 0 ? array[0] : void 0;
        }
        if (!type) {
            return import_vscode_languageserver_types.CompletionItemKind.Value;
        }
        switch(type){
            case "string":
                return import_vscode_languageserver_types.CompletionItemKind.Value;
            case "object":
                return import_vscode_languageserver_types.CompletionItemKind.Module;
            case "property":
                return import_vscode_languageserver_types.CompletionItemKind.Property;
            default:
                return import_vscode_languageserver_types.CompletionItemKind.Value;
        }
    };
    JSONCompletion2.prototype.getLabelTextForMatchingNode = function(node, document2) {
        switch(node.type){
            case "array":
                return "[]";
            case "object":
                return "{}";
            default:
                var content = document2.getText().substr(node.offset, node.length);
                return content;
        }
    };
    JSONCompletion2.prototype.getInsertTextForMatchingNode = function(node, document2, separatorAfter) {
        switch(node.type){
            case "array":
                return this.getInsertTextForValue([], separatorAfter);
            case "object":
                return this.getInsertTextForValue({}, separatorAfter);
            default:
                var content = document2.getText().substr(node.offset, node.length) + separatorAfter;
                return this.getInsertTextForPlainText(content);
        }
    };
    JSONCompletion2.prototype.getInsertTextForProperty = function(key, propertySchema, addValue, separatorAfter) {
        var propertyText = this.getInsertTextForValue(key, "");
        if (!addValue) {
            return propertyText;
        }
        var resultText = propertyText + ": ";
        var value1;
        var nValueProposals = 0;
        if (propertySchema) {
            if (Array.isArray(propertySchema.defaultSnippets)) {
                if (propertySchema.defaultSnippets.length === 1) {
                    var body = propertySchema.defaultSnippets[0].body;
                    if (isDefined(body)) {
                        value1 = this.getInsertTextForSnippetValue(body, "");
                    }
                }
                nValueProposals += propertySchema.defaultSnippets.length;
            }
            if (propertySchema.enum) {
                if (!value1 && propertySchema.enum.length === 1) {
                    value1 = this.getInsertTextForGuessedValue(propertySchema.enum[0], "");
                }
                nValueProposals += propertySchema.enum.length;
            }
            if (isDefined(propertySchema.default)) {
                if (!value1) {
                    value1 = this.getInsertTextForGuessedValue(propertySchema.default, "");
                }
                nValueProposals++;
            }
            if (Array.isArray(propertySchema.examples) && propertySchema.examples.length) {
                if (!value1) {
                    value1 = this.getInsertTextForGuessedValue(propertySchema.examples[0], "");
                }
                nValueProposals += propertySchema.examples.length;
            }
            if (nValueProposals === 0) {
                var type = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;
                if (!type) {
                    if (propertySchema.properties) {
                        type = "object";
                    } else if (propertySchema.items) {
                        type = "array";
                    }
                }
                switch(type){
                    case "boolean":
                        value1 = "$1";
                        break;
                    case "string":
                        value1 = '"$1"';
                        break;
                    case "object":
                        value1 = "{$1}";
                        break;
                    case "array":
                        value1 = "[$1]";
                        break;
                    case "number":
                    case "integer":
                        value1 = "${1:0}";
                        break;
                    case "null":
                        value1 = "${1:null}";
                        break;
                    default:
                        return propertyText;
                }
            }
        }
        if (!value1 || nValueProposals > 1) {
            value1 = "$1";
        }
        return resultText + value1 + separatorAfter;
    };
    JSONCompletion2.prototype.getCurrentWord = function(document2, offset) {
        var i = offset - 1;
        var text = document2.getText();
        while(i >= 0 && ' 	\n\r\v":{[,]}'.indexOf(text.charAt(i)) === -1){
            i--;
        }
        return text.substring(i + 1, offset);
    };
    JSONCompletion2.prototype.evaluateSeparatorAfter = function(document2, offset) {
        var scanner = createScanner2(document2.getText(), true);
        scanner.setPosition(offset);
        var token = scanner.scan();
        switch(token){
            case 5:
            case 2:
            case 4:
            case 17:
                return "";
            default:
                return ",";
        }
    };
    JSONCompletion2.prototype.findItemAtOffset = function(node, document2, offset) {
        var scanner = createScanner2(document2.getText(), true);
        var children = node.items;
        for(var i = children.length - 1; i >= 0; i--){
            var child = children[i];
            if (offset > child.offset + child.length) {
                scanner.setPosition(child.offset + child.length);
                var token = scanner.scan();
                if (token === 5 && offset >= scanner.getTokenOffset() + scanner.getTokenLength()) {
                    return i + 1;
                }
                return i;
            } else if (offset >= child.offset) {
                return i;
            }
        }
        return 0;
    };
    JSONCompletion2.prototype.isInComment = function(document2, start, offset) {
        var scanner = createScanner2(document2.getText(), false);
        scanner.setPosition(start);
        var token = scanner.scan();
        while(token !== 17 && scanner.getTokenOffset() + scanner.getTokenLength() < offset){
            token = scanner.scan();
        }
        return (token === 12 || token === 13) && scanner.getTokenOffset() <= offset;
    };
    JSONCompletion2.prototype.fromMarkup = function(markupString) {
        if (markupString && this.doesSupportMarkdown()) {
            return {
                kind: import_vscode_languageserver_types.MarkupKind.Markdown,
                value: markupString
            };
        }
        return void 0;
    };
    JSONCompletion2.prototype.doesSupportMarkdown = function() {
        if (!isDefined(this.supportsMarkdown)) {
            var completion = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.completion;
            this.supportsMarkdown = completion && completion.completionItem && Array.isArray(completion.completionItem.documentationFormat) && completion.completionItem.documentationFormat.indexOf(import_vscode_languageserver_types.MarkupKind.Markdown) !== -1;
        }
        return this.supportsMarkdown;
    };
    JSONCompletion2.prototype.doesSupportsCommitCharacters = function() {
        if (!isDefined(this.supportsCommitCharacters)) {
            var completion = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.completion;
            this.supportsCommitCharacters = completion && completion.completionItem && !!completion.completionItem.commitCharactersSupport;
        }
        return this.supportsCommitCharacters;
    };
    return JSONCompletion2;
}();
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/services/jsonHover.js
var JSONHover = /** @class */ function() {
    function JSONHover2(schemaService, contributions, promiseConstructor) {
        if (contributions === void 0) {
            contributions = [];
        }
        this.schemaService = schemaService;
        this.contributions = contributions;
        this.promise = promiseConstructor || Promise;
    }
    JSONHover2.prototype.doHover = function(document2, position, doc) {
        var offset = document2.offsetAt(position);
        var node = doc.getNodeFromOffset(offset);
        if (!node || (node.type === "object" || node.type === "array") && offset > node.offset + 1 && offset < node.offset + node.length - 1) {
            return this.promise.resolve(null);
        }
        var hoverRangeNode = node;
        if (node.type === "string") {
            var parent = node.parent;
            if (parent && parent.type === "property" && parent.keyNode === node) {
                node = parent.valueNode;
                if (!node) {
                    return this.promise.resolve(null);
                }
            }
        }
        var hoverRange = import_vscode_languageserver_types.Range.create(document2.positionAt(hoverRangeNode.offset), document2.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
        var createHover = function(contents) {
            var result = {
                contents,
                range: hoverRange
            };
            return result;
        };
        var location = getNodePath3(node);
        for(var i = this.contributions.length - 1; i >= 0; i--){
            var contribution = this.contributions[i];
            var promise = contribution.getInfoContribution(document2.uri, location);
            if (promise) {
                return promise.then(function(htmlContent) {
                    return createHover(htmlContent);
                });
            }
        }
        return this.schemaService.getSchemaForResource(document2.uri, doc).then(function(schema4) {
            if (schema4 && node) {
                var matchingSchemas = doc.getMatchingSchemas(schema4.schema, node.offset);
                var title_1 = void 0;
                var markdownDescription_1 = void 0;
                var markdownEnumValueDescription_1 = void 0, enumValue_1 = void 0;
                matchingSchemas.every(function(s) {
                    if (s.node === node && !s.inverted && s.schema) {
                        title_1 = title_1 || s.schema.title;
                        markdownDescription_1 = markdownDescription_1 || s.schema.markdownDescription || toMarkdown(s.schema.description);
                        if (s.schema.enum) {
                            var idx = s.schema.enum.indexOf(getNodeValue3(node));
                            if (s.schema.markdownEnumDescriptions) {
                                markdownEnumValueDescription_1 = s.schema.markdownEnumDescriptions[idx];
                            } else if (s.schema.enumDescriptions) {
                                markdownEnumValueDescription_1 = toMarkdown(s.schema.enumDescriptions[idx]);
                            }
                            if (markdownEnumValueDescription_1) {
                                enumValue_1 = s.schema.enum[idx];
                                if (typeof enumValue_1 !== "string") {
                                    enumValue_1 = JSON.stringify(enumValue_1);
                                }
                            }
                        }
                    }
                    return true;
                });
                var result = "";
                if (title_1) {
                    result = toMarkdown(title_1);
                }
                if (markdownDescription_1) {
                    if (result.length > 0) {
                        result += "\n\n";
                    }
                    result += markdownDescription_1;
                }
                if (markdownEnumValueDescription_1) {
                    if (result.length > 0) {
                        result += "\n\n";
                    }
                    result += "`" + toMarkdownCodeBlock(enumValue_1) + "`: " + markdownEnumValueDescription_1;
                }
                return createHover([
                    result
                ]);
            }
            return null;
        });
    };
    return JSONHover2;
}();
function toMarkdown(plain) {
    if (plain) {
        var res = plain.replace(/([^\n\r])(\r?\n)([^\n\r])/gm, "$1\n\n$3");
        return res.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
    }
    return void 0;
}
function toMarkdownCodeBlock(content) {
    if (content.indexOf("`") !== -1) {
        return "`` " + content + " ``";
    }
    return content;
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/services/jsonValidation.js
var localize5 = loadMessageBundle();
var JSONValidation = /** @class */ function() {
    function JSONValidation2(jsonSchemaService, promiseConstructor) {
        this.jsonSchemaService = jsonSchemaService;
        this.promise = promiseConstructor;
        this.validationEnabled = true;
    }
    JSONValidation2.prototype.configure = function(raw) {
        if (raw) {
            this.validationEnabled = raw.validate !== false;
            this.commentSeverity = raw.allowComments ? void 0 : import_vscode_languageserver_types.DiagnosticSeverity.Error;
        }
    };
    JSONValidation2.prototype.doValidation = function(textDocument, jsonDocument, documentSettings, schema4) {
        var _this = this;
        if (!this.validationEnabled) {
            return this.promise.resolve([]);
        }
        var diagnostics = [];
        var added = {};
        var addProblem = function(problem) {
            var signature = problem.range.start.line + " " + problem.range.start.character + " " + problem.message;
            if (!added[signature]) {
                added[signature] = true;
                diagnostics.push(problem);
            }
        };
        var getDiagnostics = function(schema5) {
            var trailingCommaSeverity = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.trailingCommas) ? toDiagnosticSeverity(documentSettings.trailingCommas) : import_vscode_languageserver_types.DiagnosticSeverity.Error;
            var commentSeverity = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.comments) ? toDiagnosticSeverity(documentSettings.comments) : _this.commentSeverity;
            var schemaValidation = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.schemaValidation) ? toDiagnosticSeverity(documentSettings.schemaValidation) : import_vscode_languageserver_types.DiagnosticSeverity.Warning;
            var schemaRequest = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.schemaRequest) ? toDiagnosticSeverity(documentSettings.schemaRequest) : import_vscode_languageserver_types.DiagnosticSeverity.Warning;
            if (schema5) {
                if (schema5.errors.length && jsonDocument.root && schemaRequest) {
                    var astRoot = jsonDocument.root;
                    var property = astRoot.type === "object" ? astRoot.properties[0] : void 0;
                    if (property && property.keyNode.value === "$schema") {
                        var node = property.valueNode || property;
                        var range = import_vscode_languageserver_types.Range.create(textDocument.positionAt(node.offset), textDocument.positionAt(node.offset + node.length));
                        addProblem(import_vscode_languageserver_types.Diagnostic.create(range, schema5.errors[0], schemaRequest, ErrorCode.SchemaResolveError));
                    } else {
                        var range = import_vscode_languageserver_types.Range.create(textDocument.positionAt(astRoot.offset), textDocument.positionAt(astRoot.offset + 1));
                        addProblem(import_vscode_languageserver_types.Diagnostic.create(range, schema5.errors[0], schemaRequest, ErrorCode.SchemaResolveError));
                    }
                } else if (schemaValidation) {
                    var semanticErrors = jsonDocument.validate(textDocument, schema5.schema, schemaValidation);
                    if (semanticErrors) {
                        semanticErrors.forEach(addProblem);
                    }
                }
                if (schemaAllowsComments(schema5.schema)) {
                    commentSeverity = void 0;
                }
                if (schemaAllowsTrailingCommas(schema5.schema)) {
                    trailingCommaSeverity = void 0;
                }
            }
            for(var _i = 0, _a = jsonDocument.syntaxErrors; _i < _a.length; _i++){
                var p = _a[_i];
                if (p.code === ErrorCode.TrailingComma) {
                    if (typeof trailingCommaSeverity !== "number") {
                        continue;
                    }
                    p.severity = trailingCommaSeverity;
                }
                addProblem(p);
            }
            if (typeof commentSeverity === "number") {
                var message_1 = localize5("InvalidCommentToken", "Comments are not permitted in JSON.");
                jsonDocument.comments.forEach(function(c) {
                    addProblem(import_vscode_languageserver_types.Diagnostic.create(c, message_1, commentSeverity, ErrorCode.CommentNotPermitted));
                });
            }
            return diagnostics;
        };
        if (schema4) {
            var id = schema4.id || "schemaservice://untitled/" + idCounter2++;
            return this.jsonSchemaService.resolveSchemaContent(new UnresolvedSchema(schema4), id, {}).then(function(resolvedSchema) {
                return getDiagnostics(resolvedSchema);
            });
        }
        return this.jsonSchemaService.getSchemaForResource(textDocument.uri, jsonDocument).then(function(schema5) {
            return getDiagnostics(schema5);
        });
    };
    return JSONValidation2;
}();
var idCounter2 = 0;
function schemaAllowsComments(schemaRef) {
    if (schemaRef && typeof schemaRef === "object") {
        if (isBoolean(schemaRef.allowComments)) {
            return schemaRef.allowComments;
        }
        if (schemaRef.allOf) {
            for(var _i = 0, _a = schemaRef.allOf; _i < _a.length; _i++){
                var schema4 = _a[_i];
                var allow = schemaAllowsComments(schema4);
                if (isBoolean(allow)) {
                    return allow;
                }
            }
        }
    }
    return void 0;
}
function schemaAllowsTrailingCommas(schemaRef) {
    if (schemaRef && typeof schemaRef === "object") {
        if (isBoolean(schemaRef.allowTrailingCommas)) {
            return schemaRef.allowTrailingCommas;
        }
        var deprSchemaRef = schemaRef;
        if (isBoolean(deprSchemaRef["allowsTrailingCommas"])) {
            return deprSchemaRef["allowsTrailingCommas"];
        }
        if (schemaRef.allOf) {
            for(var _i = 0, _a = schemaRef.allOf; _i < _a.length; _i++){
                var schema4 = _a[_i];
                var allow = schemaAllowsTrailingCommas(schema4);
                if (isBoolean(allow)) {
                    return allow;
                }
            }
        }
    }
    return void 0;
}
function toDiagnosticSeverity(severityLevel) {
    switch(severityLevel){
        case "error":
            return import_vscode_languageserver_types.DiagnosticSeverity.Error;
        case "warning":
            return import_vscode_languageserver_types.DiagnosticSeverity.Warning;
        case "ignore":
            return void 0;
    }
    return void 0;
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/utils/colors.js
var Digit0 = 48;
var Digit9 = 57;
var A = 65;
var a = 97;
var f = 102;
function hexDigit(charCode) {
    if (charCode < Digit0) {
        return 0;
    }
    if (charCode <= Digit9) {
        return charCode - Digit0;
    }
    if (charCode < a) {
        charCode += a - A;
    }
    if (charCode >= a && charCode <= f) {
        return charCode - a + 10;
    }
    return 0;
}
function colorFromHex(text) {
    if (text[0] !== "#") {
        return void 0;
    }
    switch(text.length){
        case 4:
            return {
                red: hexDigit(text.charCodeAt(1)) * 17 / 255,
                green: hexDigit(text.charCodeAt(2)) * 17 / 255,
                blue: hexDigit(text.charCodeAt(3)) * 17 / 255,
                alpha: 1
            };
        case 5:
            return {
                red: hexDigit(text.charCodeAt(1)) * 17 / 255,
                green: hexDigit(text.charCodeAt(2)) * 17 / 255,
                blue: hexDigit(text.charCodeAt(3)) * 17 / 255,
                alpha: hexDigit(text.charCodeAt(4)) * 17 / 255
            };
        case 7:
            return {
                red: (hexDigit(text.charCodeAt(1)) * 16 + hexDigit(text.charCodeAt(2))) / 255,
                green: (hexDigit(text.charCodeAt(3)) * 16 + hexDigit(text.charCodeAt(4))) / 255,
                blue: (hexDigit(text.charCodeAt(5)) * 16 + hexDigit(text.charCodeAt(6))) / 255,
                alpha: 1
            };
        case 9:
            return {
                red: (hexDigit(text.charCodeAt(1)) * 16 + hexDigit(text.charCodeAt(2))) / 255,
                green: (hexDigit(text.charCodeAt(3)) * 16 + hexDigit(text.charCodeAt(4))) / 255,
                blue: (hexDigit(text.charCodeAt(5)) * 16 + hexDigit(text.charCodeAt(6))) / 255,
                alpha: (hexDigit(text.charCodeAt(7)) * 16 + hexDigit(text.charCodeAt(8))) / 255
            };
    }
    return void 0;
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/services/jsonDocumentSymbols.js
var JSONDocumentSymbols = /** @class */ function() {
    function JSONDocumentSymbols2(schemaService) {
        this.schemaService = schemaService;
    }
    JSONDocumentSymbols2.prototype.findDocumentSymbols = function(document2, doc, context) {
        var _this = this;
        if (context === void 0) {
            context = {
                resultLimit: Number.MAX_VALUE
            };
        }
        var root = doc.root;
        if (!root) {
            return [];
        }
        var limit = context.resultLimit || Number.MAX_VALUE;
        var resourceString = document2.uri;
        if (resourceString === "vscode://defaultsettings/keybindings.json" || endsWith(resourceString.toLowerCase(), "/user/keybindings.json")) {
            if (root.type === "array") {
                var result_1 = [];
                for(var _i = 0, _a = root.items; _i < _a.length; _i++){
                    var item = _a[_i];
                    if (item.type === "object") {
                        for(var _b = 0, _c = item.properties; _b < _c.length; _b++){
                            var property = _c[_b];
                            if (property.keyNode.value === "key" && property.valueNode) {
                                var location = import_vscode_languageserver_types.Location.create(document2.uri, getRange(document2, item));
                                result_1.push({
                                    name: getNodeValue3(property.valueNode),
                                    kind: import_vscode_languageserver_types.SymbolKind.Function,
                                    location
                                });
                                limit--;
                                if (limit <= 0) {
                                    if (context && context.onResultLimitExceeded) {
                                        context.onResultLimitExceeded(resourceString);
                                    }
                                    return result_1;
                                }
                            }
                        }
                    }
                }
                return result_1;
            }
        }
        var toVisit = [
            {
                node: root,
                containerName: ""
            }
        ];
        var nextToVisit = 0;
        var limitExceeded = false;
        var result = [];
        var collectOutlineEntries = function(node, containerName) {
            if (node.type === "array") {
                node.items.forEach(function(node2) {
                    if (node2) {
                        toVisit.push({
                            node: node2,
                            containerName
                        });
                    }
                });
            } else if (node.type === "object") {
                node.properties.forEach(function(property2) {
                    var valueNode = property2.valueNode;
                    if (valueNode) {
                        if (limit > 0) {
                            limit--;
                            var location2 = import_vscode_languageserver_types.Location.create(document2.uri, getRange(document2, property2));
                            var childContainerName = containerName ? containerName + "." + property2.keyNode.value : property2.keyNode.value;
                            result.push({
                                name: _this.getKeyLabel(property2),
                                kind: _this.getSymbolKind(valueNode.type),
                                location: location2,
                                containerName
                            });
                            toVisit.push({
                                node: valueNode,
                                containerName: childContainerName
                            });
                        } else {
                            limitExceeded = true;
                        }
                    }
                });
            }
        };
        while(nextToVisit < toVisit.length){
            var next = toVisit[nextToVisit++];
            collectOutlineEntries(next.node, next.containerName);
        }
        if (limitExceeded && context && context.onResultLimitExceeded) {
            context.onResultLimitExceeded(resourceString);
        }
        return result;
    };
    JSONDocumentSymbols2.prototype.findDocumentSymbols2 = function(document2, doc, context) {
        var _this = this;
        if (context === void 0) {
            context = {
                resultLimit: Number.MAX_VALUE
            };
        }
        var root = doc.root;
        if (!root) {
            return [];
        }
        var limit = context.resultLimit || Number.MAX_VALUE;
        var resourceString = document2.uri;
        if (resourceString === "vscode://defaultsettings/keybindings.json" || endsWith(resourceString.toLowerCase(), "/user/keybindings.json")) {
            if (root.type === "array") {
                var result_2 = [];
                for(var _i = 0, _a = root.items; _i < _a.length; _i++){
                    var item = _a[_i];
                    if (item.type === "object") {
                        for(var _b = 0, _c = item.properties; _b < _c.length; _b++){
                            var property = _c[_b];
                            if (property.keyNode.value === "key" && property.valueNode) {
                                var range = getRange(document2, item);
                                var selectionRange = getRange(document2, property.keyNode);
                                result_2.push({
                                    name: getNodeValue3(property.valueNode),
                                    kind: import_vscode_languageserver_types.SymbolKind.Function,
                                    range,
                                    selectionRange
                                });
                                limit--;
                                if (limit <= 0) {
                                    if (context && context.onResultLimitExceeded) {
                                        context.onResultLimitExceeded(resourceString);
                                    }
                                    return result_2;
                                }
                            }
                        }
                    }
                }
                return result_2;
            }
        }
        var result = [];
        var toVisit = [
            {
                node: root,
                result
            }
        ];
        var nextToVisit = 0;
        var limitExceeded = false;
        var collectOutlineEntries = function(node, result2) {
            if (node.type === "array") {
                node.items.forEach(function(node2, index) {
                    if (node2) {
                        if (limit > 0) {
                            limit--;
                            var range2 = getRange(document2, node2);
                            var selectionRange2 = range2;
                            var name = String(index);
                            var symbol = {
                                name,
                                kind: _this.getSymbolKind(node2.type),
                                range: range2,
                                selectionRange: selectionRange2,
                                children: []
                            };
                            result2.push(symbol);
                            toVisit.push({
                                result: symbol.children,
                                node: node2
                            });
                        } else {
                            limitExceeded = true;
                        }
                    }
                });
            } else if (node.type === "object") {
                node.properties.forEach(function(property2) {
                    var valueNode = property2.valueNode;
                    if (valueNode) {
                        if (limit > 0) {
                            limit--;
                            var range2 = getRange(document2, property2);
                            var selectionRange2 = getRange(document2, property2.keyNode);
                            var children = [];
                            var symbol = {
                                name: _this.getKeyLabel(property2),
                                kind: _this.getSymbolKind(valueNode.type),
                                range: range2,
                                selectionRange: selectionRange2,
                                children,
                                detail: _this.getDetail(valueNode)
                            };
                            result2.push(symbol);
                            toVisit.push({
                                result: children,
                                node: valueNode
                            });
                        } else {
                            limitExceeded = true;
                        }
                    }
                });
            }
        };
        while(nextToVisit < toVisit.length){
            var next = toVisit[nextToVisit++];
            collectOutlineEntries(next.node, next.result);
        }
        if (limitExceeded && context && context.onResultLimitExceeded) {
            context.onResultLimitExceeded(resourceString);
        }
        return result;
    };
    JSONDocumentSymbols2.prototype.getSymbolKind = function(nodeType) {
        switch(nodeType){
            case "object":
                return import_vscode_languageserver_types.SymbolKind.Module;
            case "string":
                return import_vscode_languageserver_types.SymbolKind.String;
            case "number":
                return import_vscode_languageserver_types.SymbolKind.Number;
            case "array":
                return import_vscode_languageserver_types.SymbolKind.Array;
            case "boolean":
                return import_vscode_languageserver_types.SymbolKind.Boolean;
            default:
                return import_vscode_languageserver_types.SymbolKind.Variable;
        }
    };
    JSONDocumentSymbols2.prototype.getKeyLabel = function(property) {
        var name = property.keyNode.value;
        if (name) {
            name = name.replace(/[\n]/g, "\u21B5");
        }
        if (name && name.trim()) {
            return name;
        }
        return '"' + name + '"';
    };
    JSONDocumentSymbols2.prototype.getDetail = function(node) {
        if (!node) {
            return void 0;
        }
        if (node.type === "boolean" || node.type === "number" || node.type === "null" || node.type === "string") {
            return String(node.value);
        } else {
            if (node.type === "array") {
                return node.children.length ? void 0 : "[]";
            } else if (node.type === "object") {
                return node.children.length ? void 0 : "{}";
            }
        }
        return void 0;
    };
    JSONDocumentSymbols2.prototype.findDocumentColors = function(document2, doc, context) {
        return this.schemaService.getSchemaForResource(document2.uri, doc).then(function(schema4) {
            var result = [];
            if (schema4) {
                var limit = context && typeof context.resultLimit === "number" ? context.resultLimit : Number.MAX_VALUE;
                var matchingSchemas = doc.getMatchingSchemas(schema4.schema);
                var visitedNode = {};
                for(var _i = 0, matchingSchemas_1 = matchingSchemas; _i < matchingSchemas_1.length; _i++){
                    var s = matchingSchemas_1[_i];
                    if (!s.inverted && s.schema && (s.schema.format === "color" || s.schema.format === "color-hex") && s.node && s.node.type === "string") {
                        var nodeId = String(s.node.offset);
                        if (!visitedNode[nodeId]) {
                            var color = colorFromHex(getNodeValue3(s.node));
                            if (color) {
                                var range = getRange(document2, s.node);
                                result.push({
                                    color,
                                    range
                                });
                            }
                            visitedNode[nodeId] = true;
                            limit--;
                            if (limit <= 0) {
                                if (context && context.onResultLimitExceeded) {
                                    context.onResultLimitExceeded(document2.uri);
                                }
                                return result;
                            }
                        }
                    }
                }
            }
            return result;
        });
    };
    JSONDocumentSymbols2.prototype.getColorPresentations = function(document2, doc, color, range) {
        var result = [];
        var red256 = Math.round(color.red * 255), green256 = Math.round(color.green * 255), blue256 = Math.round(color.blue * 255);
        function toTwoDigitHex(n) {
            var r = n.toString(16);
            return r.length !== 2 ? "0" + r : r;
        }
        var label;
        if (color.alpha === 1) {
            label = "#" + toTwoDigitHex(red256) + toTwoDigitHex(green256) + toTwoDigitHex(blue256);
        } else {
            label = "#" + toTwoDigitHex(red256) + toTwoDigitHex(green256) + toTwoDigitHex(blue256) + toTwoDigitHex(Math.round(color.alpha * 255));
        }
        result.push({
            label,
            textEdit: import_vscode_languageserver_types.TextEdit.replace(range, JSON.stringify(label))
        });
        return result;
    };
    return JSONDocumentSymbols2;
}();
function getRange(document2, node) {
    return import_vscode_languageserver_types.Range.create(document2.positionAt(node.offset), document2.positionAt(node.offset + node.length));
}
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/services/configuration.js
var localize6 = loadMessageBundle();
var schemaContributions = {
    schemaAssociations: [],
    schemas: {
        // refer to the latest schema
        "http://json-schema.org/schema#": {
            $ref: "http://json-schema.org/draft-07/schema#"
        },
        // bundle the schema-schema to include (localized) descriptions
        "http://json-schema.org/draft-04/schema#": {
            "$schema": "http://json-schema.org/draft-04/schema#",
            "definitions": {
                "schemaArray": {
                    "type": "array",
                    "minItems": 1,
                    "items": {
                        "$ref": "#"
                    }
                },
                "positiveInteger": {
                    "type": "integer",
                    "minimum": 0
                },
                "positiveIntegerDefault0": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/positiveInteger"
                        },
                        {
                            "default": 0
                        }
                    ]
                },
                "simpleTypes": {
                    "type": "string",
                    "enum": [
                        "array",
                        "boolean",
                        "integer",
                        "null",
                        "number",
                        "object",
                        "string"
                    ]
                },
                "stringArray": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    },
                    "minItems": 1,
                    "uniqueItems": true
                }
            },
            "type": "object",
            "properties": {
                "id": {
                    "type": "string",
                    "format": "uri"
                },
                "$schema": {
                    "type": "string",
                    "format": "uri"
                },
                "title": {
                    "type": "string"
                },
                "description": {
                    "type": "string"
                },
                "default": {},
                "multipleOf": {
                    "type": "number",
                    "minimum": 0,
                    "exclusiveMinimum": true
                },
                "maximum": {
                    "type": "number"
                },
                "exclusiveMaximum": {
                    "type": "boolean",
                    "default": false
                },
                "minimum": {
                    "type": "number"
                },
                "exclusiveMinimum": {
                    "type": "boolean",
                    "default": false
                },
                "maxLength": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/positiveInteger"
                        }
                    ]
                },
                "minLength": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/positiveIntegerDefault0"
                        }
                    ]
                },
                "pattern": {
                    "type": "string",
                    "format": "regex"
                },
                "additionalItems": {
                    "anyOf": [
                        {
                            "type": "boolean"
                        },
                        {
                            "$ref": "#"
                        }
                    ],
                    "default": {}
                },
                "items": {
                    "anyOf": [
                        {
                            "$ref": "#"
                        },
                        {
                            "$ref": "#/definitions/schemaArray"
                        }
                    ],
                    "default": {}
                },
                "maxItems": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/positiveInteger"
                        }
                    ]
                },
                "minItems": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/positiveIntegerDefault0"
                        }
                    ]
                },
                "uniqueItems": {
                    "type": "boolean",
                    "default": false
                },
                "maxProperties": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/positiveInteger"
                        }
                    ]
                },
                "minProperties": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/positiveIntegerDefault0"
                        }
                    ]
                },
                "required": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/stringArray"
                        }
                    ]
                },
                "additionalProperties": {
                    "anyOf": [
                        {
                            "type": "boolean"
                        },
                        {
                            "$ref": "#"
                        }
                    ],
                    "default": {}
                },
                "definitions": {
                    "type": "object",
                    "additionalProperties": {
                        "$ref": "#"
                    },
                    "default": {}
                },
                "properties": {
                    "type": "object",
                    "additionalProperties": {
                        "$ref": "#"
                    },
                    "default": {}
                },
                "patternProperties": {
                    "type": "object",
                    "additionalProperties": {
                        "$ref": "#"
                    },
                    "default": {}
                },
                "dependencies": {
                    "type": "object",
                    "additionalProperties": {
                        "anyOf": [
                            {
                                "$ref": "#"
                            },
                            {
                                "$ref": "#/definitions/stringArray"
                            }
                        ]
                    }
                },
                "enum": {
                    "type": "array",
                    "minItems": 1,
                    "uniqueItems": true
                },
                "type": {
                    "anyOf": [
                        {
                            "$ref": "#/definitions/simpleTypes"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/simpleTypes"
                            },
                            "minItems": 1,
                            "uniqueItems": true
                        }
                    ]
                },
                "format": {
                    "anyOf": [
                        {
                            "type": "string",
                            "enum": [
                                "date-time",
                                "uri",
                                "email",
                                "hostname",
                                "ipv4",
                                "ipv6",
                                "regex"
                            ]
                        },
                        {
                            "type": "string"
                        }
                    ]
                },
                "allOf": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/schemaArray"
                        }
                    ]
                },
                "anyOf": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/schemaArray"
                        }
                    ]
                },
                "oneOf": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/schemaArray"
                        }
                    ]
                },
                "not": {
                    "allOf": [
                        {
                            "$ref": "#"
                        }
                    ]
                }
            },
            "dependencies": {
                "exclusiveMaximum": [
                    "maximum"
                ],
                "exclusiveMinimum": [
                    "minimum"
                ]
            },
            "default": {}
        },
        "http://json-schema.org/draft-07/schema#": {
            "definitions": {
                "schemaArray": {
                    "type": "array",
                    "minItems": 1,
                    "items": {
                        "$ref": "#"
                    }
                },
                "nonNegativeInteger": {
                    "type": "integer",
                    "minimum": 0
                },
                "nonNegativeIntegerDefault0": {
                    "allOf": [
                        {
                            "$ref": "#/definitions/nonNegativeInteger"
                        },
                        {
                            "default": 0
                        }
                    ]
                },
                "simpleTypes": {
                    "enum": [
                        "array",
                        "boolean",
                        "integer",
                        "null",
                        "number",
                        "object",
                        "string"
                    ]
                },
                "stringArray": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    },
                    "uniqueItems": true,
                    "default": []
                }
            },
            "type": [
                "object",
                "boolean"
            ],
            "properties": {
                "$id": {
                    "type": "string",
                    "format": "uri-reference"
                },
                "$schema": {
                    "type": "string",
                    "format": "uri"
                },
                "$ref": {
                    "type": "string",
                    "format": "uri-reference"
                },
                "$comment": {
                    "type": "string"
                },
                "title": {
                    "type": "string"
                },
                "description": {
                    "type": "string"
                },
                "default": true,
                "readOnly": {
                    "type": "boolean",
                    "default": false
                },
                "examples": {
                    "type": "array",
                    "items": true
                },
                "multipleOf": {
                    "type": "number",
                    "exclusiveMinimum": 0
                },
                "maximum": {
                    "type": "number"
                },
                "exclusiveMaximum": {
                    "type": "number"
                },
                "minimum": {
                    "type": "number"
                },
                "exclusiveMinimum": {
                    "type": "number"
                },
                "maxLength": {
                    "$ref": "#/definitions/nonNegativeInteger"
                },
                "minLength": {
                    "$ref": "#/definitions/nonNegativeIntegerDefault0"
                },
                "pattern": {
                    "type": "string",
                    "format": "regex"
                },
                "additionalItems": {
                    "$ref": "#"
                },
                "items": {
                    "anyOf": [
                        {
                            "$ref": "#"
                        },
                        {
                            "$ref": "#/definitions/schemaArray"
                        }
                    ],
                    "default": true
                },
                "maxItems": {
                    "$ref": "#/definitions/nonNegativeInteger"
                },
                "minItems": {
                    "$ref": "#/definitions/nonNegativeIntegerDefault0"
                },
                "uniqueItems": {
                    "type": "boolean",
                    "default": false
                },
                "contains": {
                    "$ref": "#"
                },
                "maxProperties": {
                    "$ref": "#/definitions/nonNegativeInteger"
                },
                "minProperties": {
                    "$ref": "#/definitions/nonNegativeIntegerDefault0"
                },
                "required": {
                    "$ref": "#/definitions/stringArray"
                },
                "additionalProperties": {
                    "$ref": "#"
                },
                "definitions": {
                    "type": "object",
                    "additionalProperties": {
                        "$ref": "#"
                    },
                    "default": {}
                },
                "properties": {
                    "type": "object",
                    "additionalProperties": {
                        "$ref": "#"
                    },
                    "default": {}
                },
                "patternProperties": {
                    "type": "object",
                    "additionalProperties": {
                        "$ref": "#"
                    },
                    "propertyNames": {
                        "format": "regex"
                    },
                    "default": {}
                },
                "dependencies": {
                    "type": "object",
                    "additionalProperties": {
                        "anyOf": [
                            {
                                "$ref": "#"
                            },
                            {
                                "$ref": "#/definitions/stringArray"
                            }
                        ]
                    }
                },
                "propertyNames": {
                    "$ref": "#"
                },
                "const": true,
                "enum": {
                    "type": "array",
                    "items": true,
                    "minItems": 1,
                    "uniqueItems": true
                },
                "type": {
                    "anyOf": [
                        {
                            "$ref": "#/definitions/simpleTypes"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/simpleTypes"
                            },
                            "minItems": 1,
                            "uniqueItems": true
                        }
                    ]
                },
                "format": {
                    "type": "string"
                },
                "contentMediaType": {
                    "type": "string"
                },
                "contentEncoding": {
                    "type": "string"
                },
                "if": {
                    "$ref": "#"
                },
                "then": {
                    "$ref": "#"
                },
                "else": {
                    "$ref": "#"
                },
                "allOf": {
                    "$ref": "#/definitions/schemaArray"
                },
                "anyOf": {
                    "$ref": "#/definitions/schemaArray"
                },
                "oneOf": {
                    "$ref": "#/definitions/schemaArray"
                },
                "not": {
                    "$ref": "#"
                }
            },
            "default": true
        }
    }
};
var descriptions = {
    id: localize6("schema.json.id", "A unique identifier for the schema."),
    $schema: localize6("schema.json.$schema", "The schema to verify this document against."),
    title: localize6("schema.json.title", "A descriptive title of the element."),
    description: localize6("schema.json.description", "A long description of the element. Used in hover menus and suggestions."),
    default: localize6("schema.json.default", "A default value. Used by suggestions."),
    multipleOf: localize6("schema.json.multipleOf", "A number that should cleanly divide the current value (i.e. have no remainder)."),
    maximum: localize6("schema.json.maximum", "The maximum numerical value, inclusive by default."),
    exclusiveMaximum: localize6("schema.json.exclusiveMaximum", "Makes the maximum property exclusive."),
    minimum: localize6("schema.json.minimum", "The minimum numerical value, inclusive by default."),
    exclusiveMinimum: localize6("schema.json.exclusiveMininum", "Makes the minimum property exclusive."),
    maxLength: localize6("schema.json.maxLength", "The maximum length of a string."),
    minLength: localize6("schema.json.minLength", "The minimum length of a string."),
    pattern: localize6("schema.json.pattern", "A regular expression to match the string against. It is not implicitly anchored."),
    additionalItems: localize6("schema.json.additionalItems", "For arrays, only when items is set as an array. If it is a schema, then this schema validates items after the ones specified by the items array. If it is false, then additional items will cause validation to fail."),
    items: localize6("schema.json.items", "For arrays. Can either be a schema to validate every element against or an array of schemas to validate each item against in order (the first schema will validate the first element, the second schema will validate the second element, and so on."),
    maxItems: localize6("schema.json.maxItems", "The maximum number of items that can be inside an array. Inclusive."),
    minItems: localize6("schema.json.minItems", "The minimum number of items that can be inside an array. Inclusive."),
    uniqueItems: localize6("schema.json.uniqueItems", "If all of the items in the array must be unique. Defaults to false."),
    maxProperties: localize6("schema.json.maxProperties", "The maximum number of properties an object can have. Inclusive."),
    minProperties: localize6("schema.json.minProperties", "The minimum number of properties an object can have. Inclusive."),
    required: localize6("schema.json.required", "An array of strings that lists the names of all properties required on this object."),
    additionalProperties: localize6("schema.json.additionalProperties", "Either a schema or a boolean. If a schema, then used to validate all properties not matched by 'properties' or 'patternProperties'. If false, then any properties not matched by either will cause this schema to fail."),
    definitions: localize6("schema.json.definitions", "Not used for validation. Place subschemas here that you wish to reference inline with $ref."),
    properties: localize6("schema.json.properties", "A map of property names to schemas for each property."),
    patternProperties: localize6("schema.json.patternProperties", "A map of regular expressions on property names to schemas for matching properties."),
    dependencies: localize6("schema.json.dependencies", "A map of property names to either an array of property names or a schema. An array of property names means the property named in the key depends on the properties in the array being present in the object in order to be valid. If the value is a schema, then the schema is only applied to the object if the property in the key exists on the object."),
    enum: localize6("schema.json.enum", "The set of literal values that are valid."),
    type: localize6("schema.json.type", "Either a string of one of the basic schema types (number, integer, null, array, object, boolean, string) or an array of strings specifying a subset of those types."),
    format: localize6("schema.json.format", "Describes the format expected for the value."),
    allOf: localize6("schema.json.allOf", "An array of schemas, all of which must match."),
    anyOf: localize6("schema.json.anyOf", "An array of schemas, where at least one must match."),
    oneOf: localize6("schema.json.oneOf", "An array of schemas, exactly one of which must match."),
    not: localize6("schema.json.not", "A schema which must not match."),
    $id: localize6("schema.json.$id", "A unique identifier for the schema."),
    $ref: localize6("schema.json.$ref", "Reference a definition hosted on any location."),
    $comment: localize6("schema.json.$comment", "Comments from schema authors to readers or maintainers of the schema."),
    readOnly: localize6("schema.json.readOnly", "Indicates that the value of the instance is managed exclusively by the owning authority."),
    examples: localize6("schema.json.examples", "Sample JSON values associated with a particular schema, for the purpose of illustrating usage."),
    contains: localize6("schema.json.contains", 'An array instance is valid against "contains" if at least one of its elements is valid against the given schema.'),
    propertyNames: localize6("schema.json.propertyNames", "If the instance is an object, this keyword validates if every property name in the instance validates against the provided schema."),
    const: localize6("schema.json.const", "An instance validates successfully against this keyword if its value is equal to the value of the keyword."),
    contentMediaType: localize6("schema.json.contentMediaType", "Describes the media type of a string property."),
    contentEncoding: localize6("schema.json.contentEncoding", "Describes the content encoding of a string property."),
    if: localize6("schema.json.if", 'The validation outcome of the "if" subschema controls which of the "then" or "else" keywords are evaluated.'),
    then: localize6("schema.json.then", 'The "if" subschema is used for validation when the "if" subschema succeeds.'),
    else: localize6("schema.json.else", 'The "else" subschema is used for validation when the "if" subschema fails.')
};
for(schemaName in schemaContributions.schemas){
    schema4 = schemaContributions.schemas[schemaName];
    for(property in schema4.properties){
        propertyObject = schema4.properties[property];
        if (typeof propertyObject === "boolean") {
            propertyObject = schema4.properties[property] = {};
        }
        description = descriptions[property];
        if (description) {
            propertyObject["description"] = description;
        } else {
            console.log(property + ": localize('schema.json." + property + `', "")`);
        }
    }
}
var schema4;
var propertyObject;
var description;
var property;
var schemaName;
// ../../node_modules/yaml-language-server/node_modules/vscode-json-languageservice/lib/esm/services/jsonLinks.js
function findLinks(document2, doc) {
    var links = [];
    doc.visit(function(node) {
        var _a;
        if (node.type === "property" && node.keyNode.value === "$ref" && ((_a = node.valueNode) === null || _a === void 0 ? void 0 : _a.type) === "string") {
            var path5 = node.valueNode.value;
            var targetNode = findTargetNode(doc, path5);
            if (targetNode) {
                var targetPos = document2.positionAt(targetNode.offset);
                links.push({
                    target: document2.uri + "#" + (targetPos.line + 1) + "," + (targetPos.character + 1),
                    range: createRange(document2, node.valueNode)
                });
            }
        }
        return true;
    });
    return Promise.resolve(links);
}
function createRange(document2, node) {
    return import_vscode_languageserver_types.Range.create(document2.positionAt(node.offset + 1), document2.positionAt(node.offset + node.length - 1));
}
function findTargetNode(doc, path5) {
    var tokens = parseJSONPointer(path5);
    if (!tokens) {
        return null;
    }
    return findNode(tokens, doc.root);
}
function findNode(pointer, node) {
    if (!node) {
        return null;
    }
    if (pointer.length === 0) {
        return node;
    }
    var token = pointer.shift();
    if (node && node.type === "object") {
        var propertyNode = node.properties.find(function(propertyNode2) {
            return propertyNode2.keyNode.value === token;
        });
        if (!propertyNode) {
            return null;
        }
        return findNode(pointer, propertyNode.valueNode);
    } else if (node && node.type === "array") {
        if (token.match(/^(0|[1-9][0-9]*)$/)) {
            var index = Number.parseInt(token);
            var arrayItem = node.items[index];
            if (!arrayItem) {
                return null;
            }
            return findNode(pointer, arrayItem);
        }
    }
    return null;
}
function parseJSONPointer(path5) {
    if (path5 === "#") {
        return [];
    }
    if (path5[0] !== "#" || path5[1] !== "/") {
        return null;
    }
    return path5.substring(2).split(/\//).map(lib_unescape);
}
function lib_unescape(str) {
    return str.replace(/~1/g, "/").replace(/~0/g, "~");
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/parser/jsonParser07.js
var import_vscode_languageserver_types2 = __toESM(require_main());
// ../../node_modules/yaml-language-server/lib/esm/languageservice/utils/arrUtils.js
function matchOffsetToDocument(offset, jsonDocuments) {
    for (const jsonDoc of jsonDocuments.documents){
        if (jsonDoc.internalDocument && jsonDoc.internalDocument.range[0] <= offset && jsonDoc.internalDocument.range[2] >= offset) {
            return jsonDoc;
        }
    }
    if (jsonDocuments.documents.length === 1) {
        return jsonDocuments.documents[0];
    }
    return null;
}
function filterInvalidCustomTags(customTags) {
    const validCustomTags = [
        "mapping",
        "scalar",
        "sequence"
    ];
    if (!customTags) {
        return [];
    }
    return customTags.filter((tag)=>{
        if (typeof tag === "string") {
            const typeInfo = tag.split(" ");
            const type = typeInfo[1] && typeInfo[1].toLowerCase() || "scalar";
            if (type === "map") {
                return false;
            }
            return validCustomTags.indexOf(type) !== -1;
        }
        return false;
    });
}
function isArrayEqual(fst, snd) {
    if (!snd || !fst) {
        return false;
    }
    if (snd.length !== fst.length) {
        return false;
    }
    for(let index = fst.length - 1; index >= 0; index--){
        if (fst[index] !== snd[index]) {
            return false;
        }
    }
    return true;
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/parser/jsonParser07.js
var localize7 = loadMessageBundle();
var MSG_PROPERTY_NOT_ALLOWED = "Property {0} is not allowed.";
var formats2 = {
    "color-hex": {
        errorMessage: localize7("colorHexFormatWarning", "Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA."),
        pattern: /^#([0-9A-Fa-f]{3,4}|([0-9A-Fa-f]{2}){3,4})$/
    },
    "date-time": {
        errorMessage: localize7("dateTimeFormatWarning", "String is not a RFC3339 date-time."),
        pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/i
    },
    date: {
        errorMessage: localize7("dateFormatWarning", "String is not a RFC3339 date."),
        pattern: /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/i
    },
    time: {
        errorMessage: localize7("timeFormatWarning", "String is not a RFC3339 time."),
        pattern: /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/i
    },
    email: {
        errorMessage: localize7("emailFormatWarning", "String is not an e-mail address."),
        pattern: /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
    },
    ipv4: {
        errorMessage: localize7("ipv4FormatWarning", "String does not match IPv4 format."),
        pattern: /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.?\b){4}$/
    },
    ipv6: {
        errorMessage: localize7("ipv6FormatWarning", "String does not match IPv6 format."),
        pattern: /^([0-9a-f]|:){1,4}(:([0-9a-f]{0,4})*){1,7}$/i
    }
};
var YAML_SOURCE = "YAML";
var YAML_SCHEMA_PREFIX = "yaml-schema: ";
var ProblemType;
(function(ProblemType2) {
    ProblemType2["missingRequiredPropWarning"] = "missingRequiredPropWarning";
    ProblemType2["typeMismatchWarning"] = "typeMismatchWarning";
    ProblemType2["constWarning"] = "constWarning";
})(ProblemType || (ProblemType = {}));
var ProblemTypeMessages = {
    [ProblemType.missingRequiredPropWarning]: 'Missing property "{0}".',
    [ProblemType.typeMismatchWarning]: 'Incorrect type. Expected "{0}".',
    [ProblemType.constWarning]: "Value must be {0}."
};
var ASTNodeImpl2 = class {
    getNodeFromOffsetEndInclusive(offset) {
        const collector = [];
        const findNode2 = (node)=>{
            if (offset >= node.offset && offset <= node.offset + node.length) {
                const children = node.children;
                for(let i = 0; i < children.length && children[i].offset <= offset; i++){
                    const item = findNode2(children[i]);
                    if (item) {
                        collector.push(item);
                    }
                }
                return node;
            }
            return null;
        };
        const foundNode = findNode2(this);
        let currMinDist = Number.MAX_VALUE;
        let currMinNode = null;
        for (const currNode of collector){
            const minDist = currNode.length + currNode.offset - offset + (offset - currNode.offset);
            if (minDist < currMinDist) {
                currMinNode = currNode;
                currMinDist = minDist;
            }
        }
        return currMinNode || foundNode;
    }
    get children() {
        return [];
    }
    toString() {
        return "type: " + this.type + " (" + this.offset + "/" + this.length + ")" + (this.parent ? " parent: {" + this.parent.toString() + "}" : "");
    }
    constructor(parent, internalNode, offset, length){
        this.offset = offset;
        this.length = length;
        this.parent = parent;
        this.internalNode = internalNode;
    }
};
var NullASTNodeImpl2 = class extends ASTNodeImpl2 {
    constructor(parent, internalNode, offset, length){
        super(parent, internalNode, offset, length);
        this.type = "null";
        this.value = null;
    }
};
var BooleanASTNodeImpl2 = class extends ASTNodeImpl2 {
    constructor(parent, internalNode, boolValue, offset, length){
        super(parent, internalNode, offset, length);
        this.type = "boolean";
        this.value = boolValue;
    }
};
var ArrayASTNodeImpl2 = class extends ASTNodeImpl2 {
    get children() {
        return this.items;
    }
    constructor(parent, internalNode, offset, length){
        super(parent, internalNode, offset, length);
        this.type = "array";
        this.items = [];
    }
};
var NumberASTNodeImpl2 = class extends ASTNodeImpl2 {
    constructor(parent, internalNode, offset, length){
        super(parent, internalNode, offset, length);
        this.type = "number";
        this.isInteger = true;
        this.value = Number.NaN;
    }
};
var StringASTNodeImpl2 = class extends ASTNodeImpl2 {
    constructor(parent, internalNode, offset, length){
        super(parent, internalNode, offset, length);
        this.type = "string";
        this.value = "";
    }
};
var PropertyASTNodeImpl2 = class extends ASTNodeImpl2 {
    get children() {
        return this.valueNode ? [
            this.keyNode,
            this.valueNode
        ] : [
            this.keyNode
        ];
    }
    constructor(parent, internalNode, offset, length){
        super(parent, internalNode, offset, length);
        this.type = "property";
        this.colonOffset = -1;
    }
};
var ObjectASTNodeImpl2 = class extends ASTNodeImpl2 {
    get children() {
        return this.properties;
    }
    constructor(parent, internalNode, offset, length){
        super(parent, internalNode, offset, length);
        this.type = "object";
        this.properties = [];
    }
};
function asSchema2(schema4) {
    if (schema4 === void 0) {
        return void 0;
    }
    if (isBoolean2(schema4)) {
        return schema4 ? {} : {
            not: {}
        };
    }
    if (typeof schema4 !== "object") {
        console.warn(`Wrong schema: ${JSON.stringify(schema4)}, it MUST be an Object or Boolean`);
        schema4 = {
            type: schema4
        };
    }
    return schema4;
}
var EnumMatch2;
(function(EnumMatch3) {
    EnumMatch3[EnumMatch3["Key"] = 0] = "Key";
    EnumMatch3[EnumMatch3["Enum"] = 1] = "Enum";
})(EnumMatch2 || (EnumMatch2 = {}));
var SchemaCollector2 = class _SchemaCollector {
    add(schema4) {
        this.schemas.push(schema4);
    }
    merge(other) {
        this.schemas.push(...other.schemas);
    }
    include(node) {
        return (this.focusOffset === -1 || contains3(node, this.focusOffset)) && node !== this.exclude;
    }
    newSub() {
        return new _SchemaCollector(-1, this.exclude);
    }
    constructor(focusOffset = -1, exclude = null){
        this.focusOffset = focusOffset;
        this.exclude = exclude;
        this.schemas = [];
    }
};
var NoOpSchemaCollector2 = class {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    get schemas() {
        return [];
    }
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    add(schema4) {}
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    merge(other) {}
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    include(node) {
        return true;
    }
    newSub() {
        return this;
    }
    constructor(){}
};
NoOpSchemaCollector2.instance = new NoOpSchemaCollector2();
var ValidationResult2 = class {
    hasProblems() {
        return !!this.problems.length;
    }
    mergeAll(validationResults) {
        for (const validationResult of validationResults){
            this.merge(validationResult);
        }
    }
    merge(validationResult) {
        this.problems = this.problems.concat(validationResult.problems);
    }
    mergeEnumValues(validationResult) {
        if (!this.enumValueMatch && !validationResult.enumValueMatch && this.enumValues && validationResult.enumValues) {
            this.enumValues = this.enumValues.concat(validationResult.enumValues);
            for (const error of this.problems){
                if (error.code === ErrorCode.EnumValueMismatch) {
                    error.message = localize7("enumWarning", "Value is not accepted. Valid values: {0}.", [
                        ...new Set(this.enumValues)
                    ].map((v)=>{
                        return JSON.stringify(v);
                    }).join(", "));
                }
            }
        }
    }
    /**
   * Merge multiple warnings with same problemType together
   * @param subValidationResult another possible result
   */ mergeWarningGeneric(subValidationResult, problemTypesToMerge) {
        var _a, _b;
        if ((_a = this.problems) == null ? void 0 : _a.length) {
            for (const problemType of problemTypesToMerge){
                const bestResults = this.problems.filter((p)=>p.problemType === problemType);
                for (const bestResult of bestResults){
                    const mergingResult = (_b = subValidationResult.problems) == null ? void 0 : _b.find((p)=>p.problemType === problemType && bestResult.location.offset === p.location.offset && (problemType !== ProblemType.missingRequiredPropWarning || isArrayEqual(p.problemArgs, bestResult.problemArgs)));
                    if (mergingResult) {
                        if (mergingResult.problemArgs.length) {
                            mergingResult.problemArgs.filter((p)=>!bestResult.problemArgs.includes(p)).forEach((p)=>bestResult.problemArgs.push(p));
                            bestResult.message = getWarningMessage(bestResult.problemType, bestResult.problemArgs);
                        }
                        this.mergeSources(mergingResult, bestResult);
                    }
                }
            }
        }
    }
    mergePropertyMatch(propertyValidationResult) {
        this.merge(propertyValidationResult);
        this.propertiesMatches++;
        if (propertyValidationResult.enumValueMatch || !propertyValidationResult.hasProblems() && propertyValidationResult.propertiesMatches) {
            this.propertiesValueMatches++;
        }
        if (propertyValidationResult.enumValueMatch && propertyValidationResult.enumValues) {
            this.primaryValueMatches++;
        }
    }
    mergeSources(mergingResult, bestResult) {
        const mergingSource = mergingResult.source.replace(YAML_SCHEMA_PREFIX, "");
        if (!bestResult.source.includes(mergingSource)) {
            bestResult.source = bestResult.source + " | " + mergingSource;
        }
        if (!bestResult.schemaUri.includes(mergingResult.schemaUri[0])) {
            bestResult.schemaUri = bestResult.schemaUri.concat(mergingResult.schemaUri);
        }
    }
    compareGeneric(other) {
        const hasProblems = this.hasProblems();
        if (hasProblems !== other.hasProblems()) {
            return hasProblems ? -1 : 1;
        }
        if (this.enumValueMatch !== other.enumValueMatch) {
            return other.enumValueMatch ? -1 : 1;
        }
        if (this.propertiesValueMatches !== other.propertiesValueMatches) {
            return this.propertiesValueMatches - other.propertiesValueMatches;
        }
        if (this.primaryValueMatches !== other.primaryValueMatches) {
            return this.primaryValueMatches - other.primaryValueMatches;
        }
        return this.propertiesMatches - other.propertiesMatches;
    }
    compareKubernetes(other) {
        const hasProblems = this.hasProblems();
        if (this.propertiesMatches !== other.propertiesMatches) {
            return this.propertiesMatches - other.propertiesMatches;
        }
        if (this.enumValueMatch !== other.enumValueMatch) {
            return other.enumValueMatch ? -1 : 1;
        }
        if (this.primaryValueMatches !== other.primaryValueMatches) {
            return this.primaryValueMatches - other.primaryValueMatches;
        }
        if (this.propertiesValueMatches !== other.propertiesValueMatches) {
            return this.propertiesValueMatches - other.propertiesValueMatches;
        }
        if (hasProblems !== other.hasProblems()) {
            return hasProblems ? -1 : 1;
        }
        return this.propertiesMatches - other.propertiesMatches;
    }
    constructor(isKubernetes){
        this.problems = [];
        this.propertiesMatches = 0;
        this.propertiesValueMatches = 0;
        this.primaryValueMatches = 0;
        this.enumValueMatch = false;
        if (isKubernetes) {
            this.enumValues = [];
        } else {
            this.enumValues = null;
        }
    }
};
function getNodeValue4(node) {
    switch(node.type){
        case "array":
            return node.children.map(getNodeValue4);
        case "object":
            {
                const obj = /* @__PURE__ */ Object.create(null);
                for(let _i = 0, _a = node.children; _i < _a.length; _i++){
                    const prop = _a[_i];
                    const valueNode = prop.children[1];
                    if (valueNode) {
                        obj[prop.children[0].value] = getNodeValue4(valueNode);
                    }
                }
                return obj;
            }
        case "null":
        case "string":
        case "number":
        case "boolean":
            return node.value;
        default:
            return void 0;
    }
}
function contains3(node, offset, includeRightBound = false) {
    return offset >= node.offset && offset <= node.offset + node.length || includeRightBound && offset === node.offset + node.length;
}
function findNodeAtOffset3(node, offset, includeRightBound) {
    if (includeRightBound === void 0) {
        includeRightBound = false;
    }
    if (contains3(node, offset, includeRightBound)) {
        const children = node.children;
        if (Array.isArray(children)) {
            for(let i = 0; i < children.length && children[i].offset <= offset; i++){
                const item = findNodeAtOffset3(children[i], offset, includeRightBound);
                if (item) {
                    return item;
                }
            }
        }
        return node;
    }
    return void 0;
}
var JSONDocument2 = class {
    getNodeFromOffset(offset, includeRightBound = false) {
        if (this.root) {
            return findNodeAtOffset3(this.root, offset, includeRightBound);
        }
        return void 0;
    }
    getNodeFromOffsetEndInclusive(offset) {
        return this.root && this.root.getNodeFromOffsetEndInclusive(offset);
    }
    visit(visitor) {
        if (this.root) {
            const doVisit = (node)=>{
                let ctn = visitor(node);
                const children = node.children;
                if (Array.isArray(children)) {
                    for(let i = 0; i < children.length && ctn; i++){
                        ctn = doVisit(children[i]);
                    }
                }
                return ctn;
            };
            doVisit(this.root);
        }
    }
    validate(textDocument, schema4) {
        if (this.root && schema4) {
            const validationResult = new ValidationResult2(this.isKubernetes);
            validate2(this.root, schema4, schema4, validationResult, NoOpSchemaCollector2.instance, {
                isKubernetes: this.isKubernetes,
                disableAdditionalProperties: this.disableAdditionalProperties,
                uri: this.uri
            });
            return validationResult.problems.map((p)=>{
                const range = import_vscode_languageserver_types2.Range.create(textDocument.positionAt(p.location.offset), textDocument.positionAt(p.location.offset + p.location.length));
                const diagnostic = import_vscode_languageserver_types2.Diagnostic.create(range, p.message, p.severity, p.code ? p.code : ErrorCode.Undefined, p.source);
                diagnostic.data = {
                    schemaUri: p.schemaUri,
                    ...p.data
                };
                return diagnostic;
            });
        }
        return null;
    }
    /**
   * This method returns the list of applicable schemas
   *
   * currently used @param didCallFromAutoComplete flag to differentiate the method call, when it is from auto complete
   * then user still types something and skip the validation for timebeing untill completed.
   * On https://github.com/redhat-developer/yaml-language-server/pull/719 the auto completes need to populate the list of enum string which matches to the enum
   * and on https://github.com/redhat-developer/vscode-yaml/issues/803 the validation should throw the error based on the enum string.
   *
   * @param schema schema
   * @param focusOffset  offsetValue
   * @param exclude excluded Node
   * @param didCallFromAutoComplete true if method called from AutoComplete
   * @returns array of applicable schemas
   */ getMatchingSchemas(schema4, focusOffset = -1, exclude = null, didCallFromAutoComplete) {
        const matchingSchemas = new SchemaCollector2(focusOffset, exclude);
        if (this.root && schema4) {
            validate2(this.root, schema4, schema4, new ValidationResult2(this.isKubernetes), matchingSchemas, {
                isKubernetes: this.isKubernetes,
                disableAdditionalProperties: this.disableAdditionalProperties,
                uri: this.uri,
                callFromAutoComplete: didCallFromAutoComplete
            });
        }
        return matchingSchemas.schemas;
    }
    constructor(root, syntaxErrors = [], comments = []){
        this.root = root;
        this.syntaxErrors = syntaxErrors;
        this.comments = comments;
    }
};
function validate2(node, schema4, originalSchema, validationResult, matchingSchemas, options) {
    const { isKubernetes, callFromAutoComplete } = options;
    if (!node) {
        return;
    }
    if (typeof schema4 !== "object") {
        return;
    }
    if (!schema4.url) {
        schema4.url = originalSchema.url;
    }
    schema4.closestTitle = schema4.title || originalSchema.closestTitle;
    switch(node.type){
        case "object":
            _validateObjectNode(node, schema4, validationResult, matchingSchemas);
            break;
        case "array":
            _validateArrayNode(node, schema4, validationResult, matchingSchemas);
            break;
        case "string":
            _validateStringNode(node, schema4, validationResult);
            break;
        case "number":
            _validateNumberNode(node, schema4, validationResult);
            break;
        case "property":
            return validate2(node.valueNode, schema4, schema4, validationResult, matchingSchemas, options);
    }
    _validateNode();
    matchingSchemas.add({
        node,
        schema: schema4
    });
    function _validateNode() {
        function matchesType(type) {
            return node.type === type || type === "integer" && node.type === "number" && node.isInteger;
        }
        if (Array.isArray(schema4.type)) {
            if (!schema4.type.some(matchesType)) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: node.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    message: schema4.errorMessage || localize7("typeArrayMismatchWarning", "Incorrect type. Expected one of {0}.", schema4.type.join(", ")),
                    source: getSchemaSource(schema4, originalSchema),
                    schemaUri: getSchemaUri(schema4, originalSchema)
                });
            }
        } else if (schema4.type) {
            if (!matchesType(schema4.type)) {
                const schemaType = schema4.type === "object" ? getSchemaTypeName(schema4) : schema4.type;
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: node.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    message: schema4.errorMessage || getWarningMessage(ProblemType.typeMismatchWarning, [
                        schemaType
                    ]),
                    source: getSchemaSource(schema4, originalSchema),
                    schemaUri: getSchemaUri(schema4, originalSchema),
                    problemType: ProblemType.typeMismatchWarning,
                    problemArgs: [
                        schemaType
                    ]
                });
            }
        }
        if (Array.isArray(schema4.allOf)) {
            for (const subSchemaRef of schema4.allOf){
                validate2(node, asSchema2(subSchemaRef), schema4, validationResult, matchingSchemas, options);
            }
        }
        const notSchema = asSchema2(schema4.not);
        if (notSchema) {
            const subValidationResult = new ValidationResult2(isKubernetes);
            const subMatchingSchemas = matchingSchemas.newSub();
            validate2(node, notSchema, schema4, subValidationResult, subMatchingSchemas, options);
            if (!subValidationResult.hasProblems()) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: node.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    message: localize7("notSchemaWarning", "Matches a schema that is not allowed."),
                    source: getSchemaSource(schema4, originalSchema),
                    schemaUri: getSchemaUri(schema4, originalSchema)
                });
            }
            for (const ms of subMatchingSchemas.schemas){
                ms.inverted = !ms.inverted;
                matchingSchemas.add(ms);
            }
        }
        const testAlternatives = (alternatives, maxOneMatch)=>{
            var _a;
            const matches = [];
            const subMatches = [];
            const noPropertyMatches = [];
            let bestMatch = null;
            for (const subSchemaRef of alternatives){
                const subSchema = {
                    ...asSchema2(subSchemaRef)
                };
                const subValidationResult = new ValidationResult2(isKubernetes);
                const subMatchingSchemas = matchingSchemas.newSub();
                validate2(node, subSchema, schema4, subValidationResult, subMatchingSchemas, options);
                if (!subValidationResult.hasProblems() || callFromAutoComplete) {
                    matches.push(subSchema);
                    subMatches.push(subSchema);
                    if (subValidationResult.propertiesMatches === 0) {
                        noPropertyMatches.push(subSchema);
                    }
                    if (subSchema.format) {
                        subMatches.pop();
                    }
                }
                if (!bestMatch) {
                    bestMatch = {
                        schema: subSchema,
                        validationResult: subValidationResult,
                        matchingSchemas: subMatchingSchemas
                    };
                } else if (isKubernetes) {
                    bestMatch = alternativeComparison(subValidationResult, bestMatch, subSchema, subMatchingSchemas);
                } else {
                    bestMatch = genericComparison(node, maxOneMatch, subValidationResult, bestMatch, subSchema, subMatchingSchemas);
                }
            }
            if (subMatches.length > 1 && (subMatches.length > 1 || noPropertyMatches.length === 0) && maxOneMatch) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: 1
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    message: localize7("oneOfWarning", "Matches multiple schemas when only one must validate."),
                    source: getSchemaSource(schema4, originalSchema),
                    schemaUri: getSchemaUri(schema4, originalSchema)
                });
            }
            if (bestMatch !== null) {
                validationResult.merge(bestMatch.validationResult);
                validationResult.propertiesMatches += bestMatch.validationResult.propertiesMatches;
                validationResult.propertiesValueMatches += bestMatch.validationResult.propertiesValueMatches;
                validationResult.enumValueMatch = validationResult.enumValueMatch || bestMatch.validationResult.enumValueMatch;
                if ((_a = bestMatch.validationResult.enumValues) == null ? void 0 : _a.length) {
                    validationResult.enumValues = (validationResult.enumValues || []).concat(bestMatch.validationResult.enumValues);
                }
                matchingSchemas.merge(bestMatch.matchingSchemas);
            }
            return matches.length;
        };
        if (Array.isArray(schema4.anyOf)) {
            testAlternatives(schema4.anyOf, false);
        }
        if (Array.isArray(schema4.oneOf)) {
            testAlternatives(schema4.oneOf, true);
        }
        const testBranch = (schema5, originalSchema2)=>{
            const subValidationResult = new ValidationResult2(isKubernetes);
            const subMatchingSchemas = matchingSchemas.newSub();
            validate2(node, asSchema2(schema5), originalSchema2, subValidationResult, subMatchingSchemas, options);
            validationResult.merge(subValidationResult);
            validationResult.propertiesMatches += subValidationResult.propertiesMatches;
            validationResult.propertiesValueMatches += subValidationResult.propertiesValueMatches;
            matchingSchemas.merge(subMatchingSchemas);
        };
        const testCondition = (ifSchema2, originalSchema2, thenSchema, elseSchema)=>{
            const subSchema = asSchema2(ifSchema2);
            const subValidationResult = new ValidationResult2(isKubernetes);
            const subMatchingSchemas = matchingSchemas.newSub();
            validate2(node, subSchema, originalSchema2, subValidationResult, subMatchingSchemas, options);
            matchingSchemas.merge(subMatchingSchemas);
            const { filePatternAssociation } = subSchema;
            if (filePatternAssociation) {
                const association = new FilePatternAssociation2(filePatternAssociation);
                if (!association.matchesPattern(options.uri)) {
                    subValidationResult.problems.push({
                        location: {
                            offset: node.offset,
                            length: node.length
                        },
                        severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                        message: localize7("ifFilePatternAssociation", `filePatternAssociation '${filePatternAssociation}' does not match with doc uri '${options.uri}'.`),
                        source: getSchemaSource(schema4, originalSchema2),
                        schemaUri: getSchemaUri(schema4, originalSchema2)
                    });
                }
            }
            if (!subValidationResult.hasProblems()) {
                if (thenSchema) {
                    testBranch(thenSchema, originalSchema2);
                }
            } else if (elseSchema) {
                testBranch(elseSchema, originalSchema2);
            }
        };
        const ifSchema = asSchema2(schema4.if);
        if (ifSchema) {
            testCondition(ifSchema, schema4, asSchema2(schema4.then), asSchema2(schema4.else));
        }
        if (Array.isArray(schema4.enum)) {
            const val = getNodeValue4(node);
            let enumValueMatch = false;
            for (const e of schema4.enum){
                if (equals2(val, e) || callFromAutoComplete && isString2(val) && isString2(e) && val && e.startsWith(val)) {
                    enumValueMatch = true;
                    break;
                }
            }
            validationResult.enumValues = schema4.enum;
            validationResult.enumValueMatch = enumValueMatch;
            if (!enumValueMatch) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: node.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    code: ErrorCode.EnumValueMismatch,
                    message: schema4.errorMessage || localize7("enumWarning", "Value is not accepted. Valid values: {0}.", schema4.enum.map((v)=>{
                        return JSON.stringify(v);
                    }).join(", ")),
                    source: getSchemaSource(schema4, originalSchema),
                    schemaUri: getSchemaUri(schema4, originalSchema)
                });
            }
        }
        if (isDefined2(schema4.const)) {
            const val = getNodeValue4(node);
            if (!equals2(val, schema4.const) && !(callFromAutoComplete && isString2(val) && isString2(schema4.const) && schema4.const.startsWith(val))) {
                validationResult.problems.push({
                    location: {
                        offset: node.offset,
                        length: node.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    code: ErrorCode.EnumValueMismatch,
                    problemType: ProblemType.constWarning,
                    message: schema4.errorMessage || getWarningMessage(ProblemType.constWarning, [
                        JSON.stringify(schema4.const)
                    ]),
                    source: getSchemaSource(schema4, originalSchema),
                    schemaUri: getSchemaUri(schema4, originalSchema),
                    problemArgs: [
                        JSON.stringify(schema4.const)
                    ]
                });
                validationResult.enumValueMatch = false;
            } else {
                validationResult.enumValueMatch = true;
            }
            validationResult.enumValues = [
                schema4.const
            ];
        }
        if (schema4.deprecationMessage && node.parent) {
            validationResult.problems.push({
                location: {
                    offset: node.parent.offset,
                    length: node.parent.length
                },
                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                message: schema4.deprecationMessage,
                source: getSchemaSource(schema4, originalSchema),
                schemaUri: getSchemaUri(schema4, originalSchema)
            });
        }
    }
    function _validateNumberNode(node2, schema5, validationResult2) {
        const val = node2.value;
        if (isNumber2(schema5.multipleOf)) {
            if (val % schema5.multipleOf !== 0) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    message: localize7("multipleOfWarning", "Value is not divisible by {0}.", schema5.multipleOf),
                    source: getSchemaSource(schema5, originalSchema),
                    schemaUri: getSchemaUri(schema5, originalSchema)
                });
            }
        }
        function getExclusiveLimit(limit, exclusive) {
            if (isNumber2(exclusive)) {
                return exclusive;
            }
            if (isBoolean2(exclusive) && exclusive) {
                return limit;
            }
            return void 0;
        }
        function getLimit(limit, exclusive) {
            if (!isBoolean2(exclusive) || !exclusive) {
                return limit;
            }
            return void 0;
        }
        const exclusiveMinimum = getExclusiveLimit(schema5.minimum, schema5.exclusiveMinimum);
        if (isNumber2(exclusiveMinimum) && val <= exclusiveMinimum) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                message: localize7("exclusiveMinimumWarning", "Value is below the exclusive minimum of {0}.", exclusiveMinimum),
                source: getSchemaSource(schema5, originalSchema),
                schemaUri: getSchemaUri(schema5, originalSchema)
            });
        }
        const exclusiveMaximum = getExclusiveLimit(schema5.maximum, schema5.exclusiveMaximum);
        if (isNumber2(exclusiveMaximum) && val >= exclusiveMaximum) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                message: localize7("exclusiveMaximumWarning", "Value is above the exclusive maximum of {0}.", exclusiveMaximum),
                source: getSchemaSource(schema5, originalSchema),
                schemaUri: getSchemaUri(schema5, originalSchema)
            });
        }
        const minimum = getLimit(schema5.minimum, schema5.exclusiveMinimum);
        if (isNumber2(minimum) && val < minimum) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                message: localize7("minimumWarning", "Value is below the minimum of {0}.", minimum),
                source: getSchemaSource(schema5, originalSchema),
                schemaUri: getSchemaUri(schema5, originalSchema)
            });
        }
        const maximum = getLimit(schema5.maximum, schema5.exclusiveMaximum);
        if (isNumber2(maximum) && val > maximum) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                message: localize7("maximumWarning", "Value is above the maximum of {0}.", maximum),
                source: getSchemaSource(schema5, originalSchema),
                schemaUri: getSchemaUri(schema5, originalSchema)
            });
        }
    }
    function _validateStringNode(node2, schema5, validationResult2) {
        if (isNumber2(schema5.minLength) && node2.value.length < schema5.minLength) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                message: localize7("minLengthWarning", "String is shorter than the minimum length of {0}.", schema5.minLength),
                source: getSchemaSource(schema5, originalSchema),
                schemaUri: getSchemaUri(schema5, originalSchema)
            });
        }
        if (isNumber2(schema5.maxLength) && node2.value.length > schema5.maxLength) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                message: localize7("maxLengthWarning", "String is longer than the maximum length of {0}.", schema5.maxLength),
                source: getSchemaSource(schema5, originalSchema),
                schemaUri: getSchemaUri(schema5, originalSchema)
            });
        }
        if (isString2(schema5.pattern)) {
            const regex = safeCreateUnicodeRegExp(schema5.pattern);
            if (!regex.test(node2.value)) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    message: schema5.patternErrorMessage || schema5.errorMessage || localize7("patternWarning", 'String does not match the pattern of "{0}".', schema5.pattern),
                    source: getSchemaSource(schema5, originalSchema),
                    schemaUri: getSchemaUri(schema5, originalSchema)
                });
            }
        }
        if (schema5.format) {
            switch(schema5.format){
                case "uri":
                case "uri-reference":
                    {
                        let errorMessage;
                        if (!node2.value) {
                            errorMessage = localize7("uriEmpty", "URI expected.");
                        } else {
                            try {
                                const uri = yaml_service_URI.parse(node2.value);
                                if (!uri.scheme && schema5.format === "uri") {
                                    errorMessage = localize7("uriSchemeMissing", "URI with a scheme is expected.");
                                }
                            } catch (e) {
                                errorMessage = e.message;
                            }
                        }
                        if (errorMessage) {
                            validationResult2.problems.push({
                                location: {
                                    offset: node2.offset,
                                    length: node2.length
                                },
                                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                                message: schema5.patternErrorMessage || schema5.errorMessage || localize7("uriFormatWarning", "String is not a URI: {0}", errorMessage),
                                source: getSchemaSource(schema5, originalSchema),
                                schemaUri: getSchemaUri(schema5, originalSchema)
                            });
                        }
                    }
                    break;
                case "color-hex":
                case "date-time":
                case "date":
                case "time":
                case "email":
                case "ipv4":
                case "ipv6":
                    {
                        const format5 = formats2[schema5.format];
                        if (!node2.value || !format5.pattern.test(node2.value)) {
                            validationResult2.problems.push({
                                location: {
                                    offset: node2.offset,
                                    length: node2.length
                                },
                                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                                message: schema5.patternErrorMessage || schema5.errorMessage || format5.errorMessage,
                                source: getSchemaSource(schema5, originalSchema),
                                schemaUri: getSchemaUri(schema5, originalSchema)
                            });
                        }
                    }
                    break;
                default:
            }
        }
    }
    function _validateArrayNode(node2, schema5, validationResult2, matchingSchemas2) {
        if (Array.isArray(schema5.items)) {
            const subSchemas = schema5.items;
            for(let index = 0; index < subSchemas.length; index++){
                const subSchemaRef = subSchemas[index];
                const subSchema = asSchema2(subSchemaRef);
                const itemValidationResult = new ValidationResult2(isKubernetes);
                const item = node2.items[index];
                if (item) {
                    validate2(item, subSchema, schema5, itemValidationResult, matchingSchemas2, options);
                    validationResult2.mergePropertyMatch(itemValidationResult);
                    validationResult2.mergeEnumValues(itemValidationResult);
                } else if (node2.items.length >= subSchemas.length) {
                    validationResult2.propertiesValueMatches++;
                }
            }
            if (node2.items.length > subSchemas.length) {
                if (typeof schema5.additionalItems === "object") {
                    for(let i = subSchemas.length; i < node2.items.length; i++){
                        const itemValidationResult = new ValidationResult2(isKubernetes);
                        validate2(node2.items[i], schema5.additionalItems, schema5, itemValidationResult, matchingSchemas2, options);
                        validationResult2.mergePropertyMatch(itemValidationResult);
                        validationResult2.mergeEnumValues(itemValidationResult);
                    }
                } else if (schema5.additionalItems === false) {
                    validationResult2.problems.push({
                        location: {
                            offset: node2.offset,
                            length: node2.length
                        },
                        severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                        message: localize7("additionalItemsWarning", "Array has too many items according to schema. Expected {0} or fewer.", subSchemas.length),
                        source: getSchemaSource(schema5, originalSchema),
                        schemaUri: getSchemaUri(schema5, originalSchema)
                    });
                }
            }
        } else {
            const itemSchema = asSchema2(schema5.items);
            if (itemSchema) {
                const itemValidationResult = new ValidationResult2(isKubernetes);
                node2.items.forEach((item)=>{
                    if (itemSchema.oneOf && itemSchema.oneOf.length === 1) {
                        const subSchemaRef = itemSchema.oneOf[0];
                        const subSchema = {
                            ...asSchema2(subSchemaRef)
                        };
                        subSchema.title = schema5.title;
                        subSchema.closestTitle = schema5.closestTitle;
                        validate2(item, subSchema, schema5, itemValidationResult, matchingSchemas2, options);
                        validationResult2.mergePropertyMatch(itemValidationResult);
                        validationResult2.mergeEnumValues(itemValidationResult);
                    } else {
                        validate2(item, itemSchema, schema5, itemValidationResult, matchingSchemas2, options);
                        validationResult2.mergePropertyMatch(itemValidationResult);
                        validationResult2.mergeEnumValues(itemValidationResult);
                    }
                });
            }
        }
        const containsSchema = asSchema2(schema5.contains);
        if (containsSchema) {
            const doesContain = node2.items.some((item)=>{
                const itemValidationResult = new ValidationResult2(isKubernetes);
                validate2(item, containsSchema, schema5, itemValidationResult, NoOpSchemaCollector2.instance, options);
                return !itemValidationResult.hasProblems();
            });
            if (!doesContain) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    message: schema5.errorMessage || localize7("requiredItemMissingWarning", "Array does not contain required item."),
                    source: getSchemaSource(schema5, originalSchema),
                    schemaUri: getSchemaUri(schema5, originalSchema)
                });
            }
        }
        if (isNumber2(schema5.minItems) && node2.items.length < schema5.minItems) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                message: localize7("minItemsWarning", "Array has too few items. Expected {0} or more.", schema5.minItems),
                source: getSchemaSource(schema5, originalSchema),
                schemaUri: getSchemaUri(schema5, originalSchema)
            });
        }
        if (isNumber2(schema5.maxItems) && node2.items.length > schema5.maxItems) {
            validationResult2.problems.push({
                location: {
                    offset: node2.offset,
                    length: node2.length
                },
                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                message: localize7("maxItemsWarning", "Array has too many items. Expected {0} or fewer.", schema5.maxItems),
                source: getSchemaSource(schema5, originalSchema),
                schemaUri: getSchemaUri(schema5, originalSchema)
            });
        }
        if (schema5.uniqueItems === true) {
            const values = getNodeValue4(node2);
            const duplicates = values.some((value1, index)=>{
                return index !== values.lastIndexOf(value1);
            });
            if (duplicates) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    message: localize7("uniqueItemsWarning", "Array has duplicate items."),
                    source: getSchemaSource(schema5, originalSchema),
                    schemaUri: getSchemaUri(schema5, originalSchema)
                });
            }
        }
    }
    function _validateObjectNode(node2, schema5, validationResult2, matchingSchemas2) {
        var _a;
        const seenKeys = /* @__PURE__ */ Object.create(null);
        const unprocessedProperties = [];
        const unprocessedNodes = [
            ...node2.properties
        ];
        while(unprocessedNodes.length > 0){
            const propertyNode = unprocessedNodes.pop();
            const key = propertyNode.keyNode.value;
            if (key === "<<" && propertyNode.valueNode) {
                switch(propertyNode.valueNode.type){
                    case "object":
                        {
                            unprocessedNodes.push(...propertyNode.valueNode["properties"]);
                            break;
                        }
                    case "array":
                        {
                            propertyNode.valueNode["items"].forEach((sequenceNode)=>{
                                if (sequenceNode && isIterable(sequenceNode["properties"])) {
                                    unprocessedNodes.push(...sequenceNode["properties"]);
                                }
                            });
                            break;
                        }
                    default:
                        {
                            break;
                        }
                }
            } else {
                seenKeys[key] = propertyNode.valueNode;
                unprocessedProperties.push(key);
            }
        }
        if (Array.isArray(schema5.required)) {
            for (const propertyName of schema5.required){
                if (seenKeys[propertyName] === void 0) {
                    const keyNode = node2.parent && node2.parent.type === "property" && node2.parent.keyNode;
                    const location = keyNode ? {
                        offset: keyNode.offset,
                        length: keyNode.length
                    } : {
                        offset: node2.offset,
                        length: 1
                    };
                    validationResult2.problems.push({
                        location,
                        severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                        message: getWarningMessage(ProblemType.missingRequiredPropWarning, [
                            propertyName
                        ]),
                        source: getSchemaSource(schema5, originalSchema),
                        schemaUri: getSchemaUri(schema5, originalSchema),
                        problemArgs: [
                            propertyName
                        ],
                        problemType: ProblemType.missingRequiredPropWarning
                    });
                }
            }
        }
        const propertyProcessed = (prop)=>{
            let index = unprocessedProperties.indexOf(prop);
            while(index >= 0){
                unprocessedProperties.splice(index, 1);
                index = unprocessedProperties.indexOf(prop);
            }
        };
        if (schema5.properties) {
            for (const propertyName of Object.keys(schema5.properties)){
                propertyProcessed(propertyName);
                const propertySchema = schema5.properties[propertyName];
                const child = seenKeys[propertyName];
                if (child) {
                    if (isBoolean2(propertySchema)) {
                        if (!propertySchema) {
                            const propertyNode = child.parent;
                            validationResult2.problems.push({
                                location: {
                                    offset: propertyNode.keyNode.offset,
                                    length: propertyNode.keyNode.length
                                },
                                severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                                message: schema5.errorMessage || localize7("DisallowedExtraPropWarning", MSG_PROPERTY_NOT_ALLOWED, propertyName),
                                source: getSchemaSource(schema5, originalSchema),
                                schemaUri: getSchemaUri(schema5, originalSchema)
                            });
                        } else {
                            validationResult2.propertiesMatches++;
                            validationResult2.propertiesValueMatches++;
                        }
                    } else {
                        propertySchema.url = (_a = schema5.url) != null ? _a : originalSchema.url;
                        const propertyValidationResult = new ValidationResult2(isKubernetes);
                        validate2(child, propertySchema, schema5, propertyValidationResult, matchingSchemas2, options);
                        validationResult2.mergePropertyMatch(propertyValidationResult);
                        validationResult2.mergeEnumValues(propertyValidationResult);
                    }
                }
            }
        }
        if (schema5.patternProperties) {
            for (const propertyPattern of Object.keys(schema5.patternProperties)){
                const regex = safeCreateUnicodeRegExp(propertyPattern);
                for (const propertyName of unprocessedProperties.slice(0)){
                    if (regex.test(propertyName)) {
                        propertyProcessed(propertyName);
                        const child = seenKeys[propertyName];
                        if (child) {
                            const propertySchema = schema5.patternProperties[propertyPattern];
                            if (isBoolean2(propertySchema)) {
                                if (!propertySchema) {
                                    const propertyNode = child.parent;
                                    validationResult2.problems.push({
                                        location: {
                                            offset: propertyNode.keyNode.offset,
                                            length: propertyNode.keyNode.length
                                        },
                                        severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                                        message: schema5.errorMessage || localize7("DisallowedExtraPropWarning", MSG_PROPERTY_NOT_ALLOWED, propertyName),
                                        source: getSchemaSource(schema5, originalSchema),
                                        schemaUri: getSchemaUri(schema5, originalSchema)
                                    });
                                } else {
                                    validationResult2.propertiesMatches++;
                                    validationResult2.propertiesValueMatches++;
                                }
                            } else {
                                const propertyValidationResult = new ValidationResult2(isKubernetes);
                                validate2(child, propertySchema, schema5, propertyValidationResult, matchingSchemas2, options);
                                validationResult2.mergePropertyMatch(propertyValidationResult);
                                validationResult2.mergeEnumValues(propertyValidationResult);
                            }
                        }
                    }
                }
            }
        }
        if (typeof schema5.additionalProperties === "object") {
            for (const propertyName of unprocessedProperties){
                const child = seenKeys[propertyName];
                if (child) {
                    const propertyValidationResult = new ValidationResult2(isKubernetes);
                    validate2(child, schema5.additionalProperties, schema5, propertyValidationResult, matchingSchemas2, options);
                    validationResult2.mergePropertyMatch(propertyValidationResult);
                    validationResult2.mergeEnumValues(propertyValidationResult);
                }
            }
        } else if (schema5.additionalProperties === false || schema5.type === "object" && schema5.additionalProperties === void 0 && options.disableAdditionalProperties === true) {
            if (unprocessedProperties.length > 0) {
                const possibleProperties = schema5.properties && Object.keys(schema5.properties).filter((prop)=>!seenKeys[prop]);
                for (const propertyName of unprocessedProperties){
                    const child = seenKeys[propertyName];
                    if (child) {
                        let propertyNode = null;
                        if (child.type !== "property") {
                            propertyNode = child.parent;
                            if (propertyNode.type === "object") {
                                propertyNode = propertyNode.properties[0];
                            }
                        } else {
                            propertyNode = child;
                        }
                        const problem = {
                            location: {
                                offset: propertyNode.keyNode.offset,
                                length: propertyNode.keyNode.length
                            },
                            severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                            message: schema5.errorMessage || localize7("DisallowedExtraPropWarning", MSG_PROPERTY_NOT_ALLOWED, propertyName),
                            source: getSchemaSource(schema5, originalSchema),
                            schemaUri: getSchemaUri(schema5, originalSchema)
                        };
                        if (possibleProperties == null ? void 0 : possibleProperties.length) {
                            problem.data = {
                                properties: possibleProperties
                            };
                        }
                        validationResult2.problems.push(problem);
                    }
                }
            }
        }
        if (isNumber2(schema5.maxProperties)) {
            if (node2.properties.length > schema5.maxProperties) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    message: localize7("MaxPropWarning", "Object has more properties than limit of {0}.", schema5.maxProperties),
                    source: getSchemaSource(schema5, originalSchema),
                    schemaUri: getSchemaUri(schema5, originalSchema)
                });
            }
        }
        if (isNumber2(schema5.minProperties)) {
            if (node2.properties.length < schema5.minProperties) {
                validationResult2.problems.push({
                    location: {
                        offset: node2.offset,
                        length: node2.length
                    },
                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                    message: localize7("MinPropWarning", "Object has fewer properties than the required number of {0}", schema5.minProperties),
                    source: getSchemaSource(schema5, originalSchema),
                    schemaUri: getSchemaUri(schema5, originalSchema)
                });
            }
        }
        if (schema5.dependencies) {
            for (const key of Object.keys(schema5.dependencies)){
                const prop = seenKeys[key];
                if (prop) {
                    const propertyDep = schema5.dependencies[key];
                    if (Array.isArray(propertyDep)) {
                        for (const requiredProp of propertyDep){
                            if (!seenKeys[requiredProp]) {
                                validationResult2.problems.push({
                                    location: {
                                        offset: node2.offset,
                                        length: node2.length
                                    },
                                    severity: import_vscode_languageserver_types2.DiagnosticSeverity.Warning,
                                    message: localize7("RequiredDependentPropWarning", "Object is missing property {0} required by property {1}.", requiredProp, key),
                                    source: getSchemaSource(schema5, originalSchema),
                                    schemaUri: getSchemaUri(schema5, originalSchema)
                                });
                            } else {
                                validationResult2.propertiesValueMatches++;
                            }
                        }
                    } else {
                        const propertySchema = asSchema2(propertyDep);
                        if (propertySchema) {
                            const propertyValidationResult = new ValidationResult2(isKubernetes);
                            validate2(node2, propertySchema, schema5, propertyValidationResult, matchingSchemas2, options);
                            validationResult2.mergePropertyMatch(propertyValidationResult);
                            validationResult2.mergeEnumValues(propertyValidationResult);
                        }
                    }
                }
            }
        }
        const propertyNames = asSchema2(schema5.propertyNames);
        if (propertyNames) {
            for (const f2 of node2.properties){
                const key = f2.keyNode;
                if (key) {
                    validate2(key, propertyNames, schema5, validationResult2, NoOpSchemaCollector2.instance, options);
                }
            }
        }
    }
    function alternativeComparison(subValidationResult, bestMatch, subSchema, subMatchingSchemas) {
        const compareResult = subValidationResult.compareKubernetes(bestMatch.validationResult);
        if (compareResult > 0) {
            bestMatch = {
                schema: subSchema,
                validationResult: subValidationResult,
                matchingSchemas: subMatchingSchemas
            };
        } else if (compareResult === 0) {
            bestMatch.matchingSchemas.merge(subMatchingSchemas);
            bestMatch.validationResult.mergeEnumValues(subValidationResult);
        }
        return bestMatch;
    }
    function genericComparison(node2, maxOneMatch, subValidationResult, bestMatch, subSchema, subMatchingSchemas) {
        if (!maxOneMatch && !subValidationResult.hasProblems() && (!bestMatch.validationResult.hasProblems() || callFromAutoComplete)) {
            bestMatch.matchingSchemas.merge(subMatchingSchemas);
            bestMatch.validationResult.propertiesMatches += subValidationResult.propertiesMatches;
            bestMatch.validationResult.propertiesValueMatches += subValidationResult.propertiesValueMatches;
        } else {
            const compareResult = subValidationResult.compareGeneric(bestMatch.validationResult);
            if (compareResult > 0 || compareResult === 0 && maxOneMatch && bestMatch.schema.type === "object" && node2.type !== "null" && node2.type !== bestMatch.schema.type) {
                bestMatch = {
                    schema: subSchema,
                    validationResult: subValidationResult,
                    matchingSchemas: subMatchingSchemas
                };
            } else if (compareResult === 0) {
                bestMatch.matchingSchemas.merge(subMatchingSchemas);
                bestMatch.validationResult.mergeEnumValues(subValidationResult);
                bestMatch.validationResult.mergeWarningGeneric(subValidationResult, [
                    ProblemType.missingRequiredPropWarning,
                    ProblemType.typeMismatchWarning,
                    ProblemType.constWarning
                ]);
            }
        }
        return bestMatch;
    }
}
function getSchemaSource(schema4, originalSchema) {
    var _a;
    if (schema4) {
        let label;
        if (schema4.title) {
            label = schema4.title;
        } else if (schema4.closestTitle) {
            label = schema4.closestTitle;
        } else if (originalSchema.closestTitle) {
            label = originalSchema.closestTitle;
        } else {
            const uriString = (_a = schema4.url) != null ? _a : originalSchema.url;
            if (uriString) {
                const url = yaml_service_URI.parse(uriString);
                if (url.scheme === "file") {
                    label = url.fsPath;
                }
                label = url.toString();
            }
        }
        if (label) {
            return `${YAML_SCHEMA_PREFIX}${label}`;
        }
    }
    return YAML_SOURCE;
}
function getSchemaUri(schema4, originalSchema) {
    var _a;
    const uriString = (_a = schema4.url) != null ? _a : originalSchema.url;
    return uriString ? [
        uriString
    ] : [];
}
function getWarningMessage(problemType, args) {
    return localize7(problemType, ProblemTypeMessages[problemType], args.join(" | "));
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/parser/ast-converter.js
var maxRefCount = 1e3;
var refDepth = 0;
var seenAlias = /* @__PURE__ */ new Set();
function convertAST(parent, node, doc, lineCounter) {
    if (!parent) {
        refDepth = 0;
    }
    if (!node) {
        return null;
    }
    if (isMap(node)) {
        return convertMap(node, parent, doc, lineCounter);
    }
    if (isPair(node)) {
        return convertPair(node, parent, doc, lineCounter);
    }
    if (isSeq(node)) {
        return convertSeq(node, parent, doc, lineCounter);
    }
    if (isScalar(node)) {
        return convertScalar(node, parent);
    }
    if (isAlias(node) && !seenAlias.has(node) && refDepth < maxRefCount) {
        seenAlias.add(node);
        const converted = convertAlias(node, parent, doc, lineCounter);
        seenAlias.delete(node);
        return converted;
    } else {
        return;
    }
}
function convertMap(node, parent, doc, lineCounter) {
    let range;
    if (node.flow && !node.range) {
        range = collectFlowMapRange(node);
    } else {
        range = node.range;
    }
    const result = new ObjectASTNodeImpl2(parent, node, ...toFixedOffsetLength(range, lineCounter));
    for (const it of node.items){
        if (isPair(it)) {
            result.properties.push(convertAST(result, it, doc, lineCounter));
        }
    }
    return result;
}
function convertPair(node, parent, doc, lineCounter) {
    const keyNode = node.key;
    const valueNode = node.value;
    const rangeStart = keyNode.range[0];
    let rangeEnd = keyNode.range[1];
    let nodeEnd = keyNode.range[2];
    if (valueNode) {
        rangeEnd = valueNode.range[1];
        nodeEnd = valueNode.range[2];
    }
    const result = new PropertyASTNodeImpl2(parent, node, ...toFixedOffsetLength([
        rangeStart,
        rangeEnd,
        nodeEnd
    ], lineCounter));
    if (isAlias(keyNode)) {
        const keyAlias = new StringASTNodeImpl2(parent, keyNode, ...toOffsetLength(keyNode.range));
        keyAlias.value = keyNode.source;
        result.keyNode = keyAlias;
    } else {
        result.keyNode = convertAST(result, keyNode, doc, lineCounter);
    }
    result.valueNode = convertAST(result, valueNode, doc, lineCounter);
    return result;
}
function convertSeq(node, parent, doc, lineCounter) {
    const result = new ArrayASTNodeImpl2(parent, node, ...toOffsetLength(node.range));
    for (const it of node.items){
        if (isNode(it)) {
            const convertedNode = convertAST(result, it, doc, lineCounter);
            if (convertedNode) {
                result.children.push(convertedNode);
            }
        }
    }
    return result;
}
function convertScalar(node, parent) {
    if (node.value === null) {
        return new NullASTNodeImpl2(parent, node, ...toOffsetLength(node.range));
    }
    switch(typeof node.value){
        case "string":
            {
                const result = new StringASTNodeImpl2(parent, node, ...toOffsetLength(node.range));
                result.value = node.value;
                return result;
            }
        case "boolean":
            return new BooleanASTNodeImpl2(parent, node, node.value, ...toOffsetLength(node.range));
        case "number":
            {
                const result = new NumberASTNodeImpl2(parent, node, ...toOffsetLength(node.range));
                result.value = node.value;
                result.isInteger = Number.isInteger(result.value);
                return result;
            }
        default:
            {
                const result = new StringASTNodeImpl2(parent, node, ...toOffsetLength(node.range));
                result.value = node.source;
                return result;
            }
    }
}
function convertAlias(node, parent, doc, lineCounter) {
    refDepth++;
    const resolvedNode = node.resolve(doc);
    if (resolvedNode) {
        return convertAST(parent, resolvedNode, doc, lineCounter);
    } else {
        const resultNode = new StringASTNodeImpl2(parent, node, ...toOffsetLength(node.range));
        resultNode.value = node.source;
        return resultNode;
    }
}
function toOffsetLength(range) {
    return [
        range[0],
        range[1] - range[0]
    ];
}
function toFixedOffsetLength(range, lineCounter) {
    const start = lineCounter.linePos(range[0]);
    const end = lineCounter.linePos(range[1]);
    const result = [
        range[0],
        range[1] - range[0]
    ];
    if (start.line !== end.line && (lineCounter.lineStarts.length !== end.line || end.col === 1)) {
        result[1]--;
    }
    return result;
}
function collectFlowMapRange(node) {
    let start = Number.MAX_SAFE_INTEGER;
    let end = 0;
    for (const it of node.items){
        if (isPair(it)) {
            if (isNode(it.key)) {
                if (it.key.range && it.key.range[0] <= start) {
                    start = it.key.range[0];
                }
            }
            if (isNode(it.value)) {
                if (it.value.range && it.value.range[2] >= end) {
                    end = it.value.range[2];
                }
            }
        }
    }
    return [
        start,
        end,
        end
    ];
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/utils/astUtils.js
function getParent(doc, nodeToFind) {
    let parentNode;
    visit2(doc, (_2, node, path5)=>{
        if (node === nodeToFind) {
            parentNode = path5[path5.length - 1];
            return visit2.BREAK;
        }
    });
    if (isDocument(parentNode)) {
        return void 0;
    }
    return parentNode;
}
function isMapContainsEmptyPair(map2) {
    if (map2.items.length > 1) {
        return false;
    }
    const pair = map2.items[0];
    return isScalar(pair.key) && isScalar(pair.value) && pair.key.value === "" && !pair.value.value;
}
function indexOf(seq2, item) {
    for (const [i, obj] of seq2.items.entries()){
        if (item === obj) {
            return i;
        }
    }
    return void 0;
}
function isInComment(tokens, offset) {
    let inComment = false;
    for (const token of tokens){
        if (token.type === "document") {
            _visit2([], token, (item)=>{
                var _a;
                if (isCollectionItem(item) && ((_a = item.value) == null ? void 0 : _a.type) === "comment") {
                    if (token.offset <= offset && item.value.source.length + item.value.offset >= offset) {
                        inComment = true;
                        return visit2.BREAK;
                    }
                } else if (item.type === "comment" && item.offset <= offset && item.offset + item.source.length >= offset) {
                    inComment = true;
                    return visit2.BREAK;
                }
            });
        } else if (token.type === "comment") {
            if (token.offset <= offset && token.source.length + token.offset >= offset) {
                return true;
            }
        }
        if (inComment) {
            break;
        }
    }
    return inComment;
}
function isCollectionItem(token) {
    return token["start"] !== void 0;
}
function _visit2(path5, item, visitor) {
    let ctrl = visitor(item, path5);
    if (typeof ctrl === "symbol") return ctrl;
    for (const field of [
        "key",
        "value"
    ]){
        const token2 = item[field];
        if (token2 && "items" in token2) {
            for(let i = 0; i < token2.items.length; ++i){
                const ci = _visit2(Object.freeze(path5.concat([
                    [
                        field,
                        i
                    ]
                ])), token2.items[i], visitor);
                if (typeof ci === "number") i = ci - 1;
                else if (ci === visit2.BREAK) return visit2.BREAK;
                else if (ci === visit2.REMOVE) {
                    token2.items.splice(i, 1);
                    i -= 1;
                }
            }
            if (typeof ctrl === "function" && field === "key") ctrl = ctrl(item, path5);
        }
    }
    const token = item["sep"];
    if (token) {
        for(let i = 0; i < token.length; ++i){
            const ci = _visit2(Object.freeze(path5), token[i], visitor);
            if (typeof ci === "number") i = ci - 1;
            else if (ci === visit2.BREAK) return visit2.BREAK;
            else if (ci === visit2.REMOVE) {
                token.items.splice(i, 1);
                i -= 1;
            }
        }
    }
    return typeof ctrl === "function" ? ctrl(item, path5) : ctrl;
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/parser/yaml-documents.js
var SingleYAMLDocument = class _SingleYAMLDocument extends JSONDocument2 {
    /**
   * Create a deep copy of this document
   */ clone() {
        const copy = new _SingleYAMLDocument(this.lineCounter);
        copy.isKubernetes = this.isKubernetes;
        copy.disableAdditionalProperties = this.disableAdditionalProperties;
        copy.uri = this.uri;
        copy.currentDocIndex = this.currentDocIndex;
        copy._lineComments = this.lineComments.slice();
        copy.internalDocument = this._internalDocument.clone();
        return copy;
    }
    collectLineComments() {
        this._lineComments = [];
        if (this._internalDocument.commentBefore) {
            const comments = this._internalDocument.commentBefore.split("\n");
            comments.forEach((comment)=>this._lineComments.push(`#${comment}`));
        }
        visit2(this.internalDocument, (_key, node)=>{
            if (node == null ? void 0 : node.commentBefore) {
                const comments = node == null ? void 0 : node.commentBefore.split("\n");
                comments.forEach((comment)=>this._lineComments.push(`#${comment}`));
            }
            if (node == null ? void 0 : node.comment) {
                this._lineComments.push(`#${node.comment}`);
            }
        });
        if (this._internalDocument.comment) {
            this._lineComments.push(`#${this._internalDocument.comment}`);
        }
    }
    /**
   * Updates the internal AST tree of the object
   * from the internal node. This is call whenever the
   * internalDocument is set but also can be called to
   * reflect any changes on the underlying document
   * without setting the internalDocument explicitly.
   */ updateFromInternalDocument() {
        this.root = convertAST(null, this._internalDocument.contents, this._internalDocument, this.lineCounter);
    }
    set internalDocument(document2) {
        this._internalDocument = document2;
        this.updateFromInternalDocument();
    }
    get internalDocument() {
        return this._internalDocument;
    }
    get lineComments() {
        if (!this._lineComments) {
            this.collectLineComments();
        }
        return this._lineComments;
    }
    set lineComments(val) {
        this._lineComments = val;
    }
    get errors() {
        return this.internalDocument.errors.map(YAMLErrorToYamlDocDiagnostics);
    }
    get warnings() {
        return this.internalDocument.warnings.map(YAMLErrorToYamlDocDiagnostics);
    }
    getNodeFromPosition(positionOffset, textBuffer, configuredIndentation) {
        const position = textBuffer.getPosition(positionOffset);
        const lineContent = textBuffer.getLineContent(position.line);
        if (lineContent.trim().length === 0) {
            return [
                this.findClosestNode(positionOffset, textBuffer, configuredIndentation),
                true
            ];
        }
        const textAfterPosition = lineContent.substring(position.character);
        const spacesAfterPositionMatch = textAfterPosition.match(/^([ ]+)\n?$/);
        const areOnlySpacesAfterPosition = !!spacesAfterPositionMatch;
        const countOfSpacesAfterPosition = spacesAfterPositionMatch == null ? void 0 : spacesAfterPositionMatch[1].length;
        let closestNode;
        visit2(this.internalDocument, (key, node)=>{
            if (!node) {
                return;
            }
            const range = node.range;
            if (!range) {
                return;
            }
            const isNullNodeOnTheLine = ()=>areOnlySpacesAfterPosition && positionOffset + countOfSpacesAfterPosition === range[2] && isScalar(node) && node.value === null;
            if (range[0] <= positionOffset && range[1] >= positionOffset || isNullNodeOnTheLine()) {
                closestNode = node;
            } else {
                return visit2.SKIP;
            }
        });
        return [
            closestNode,
            false
        ];
    }
    findClosestNode(offset, textBuffer, configuredIndentation) {
        let offsetDiff = this.internalDocument.range[2];
        let maxOffset = this.internalDocument.range[0];
        let closestNode;
        visit2(this.internalDocument, (key, node)=>{
            if (!node) {
                return;
            }
            const range = node.range;
            if (!range) {
                return;
            }
            const diff = range[1] - offset;
            if (maxOffset <= range[0] && diff <= 0 && Math.abs(diff) <= offsetDiff) {
                offsetDiff = Math.abs(diff);
                maxOffset = range[0];
                closestNode = node;
            }
        });
        const position = textBuffer.getPosition(offset);
        const lineContent = textBuffer.getLineContent(position.line);
        const indentation = getIndentation(lineContent, position.character);
        if (isScalar(closestNode) && closestNode.value === null) {
            return closestNode;
        }
        if (indentation === position.character) {
            closestNode = this.getProperParentByIndentation(indentation, closestNode, textBuffer, "", configuredIndentation);
        }
        return closestNode;
    }
    getProperParentByIndentation(indentation, node, textBuffer, currentLine, configuredIndentation, rootParent) {
        if (!node) {
            return this.internalDocument.contents;
        }
        configuredIndentation = !configuredIndentation ? 2 : configuredIndentation;
        if (isNode(node) && node.range) {
            const position = textBuffer.getPosition(node.range[0]);
            const lineContent = textBuffer.getLineContent(position.line);
            currentLine = currentLine === "" ? lineContent.trim() : currentLine;
            if (currentLine.startsWith("-") && indentation === configuredIndentation && currentLine === lineContent.trim()) {
                position.character += indentation;
            }
            if (position.character > indentation && position.character > 0) {
                const parent = this.getParent(node);
                if (parent) {
                    return this.getProperParentByIndentation(indentation, parent, textBuffer, currentLine, configuredIndentation, rootParent);
                }
            } else if (position.character < indentation) {
                const parent = this.getParent(node);
                if (isPair(parent) && isNode(parent.value)) {
                    return parent.value;
                } else if (isPair(rootParent) && isNode(rootParent.value)) {
                    return rootParent.value;
                }
            } else {
                return node;
            }
        } else if (isPair(node)) {
            rootParent = node;
            const parent = this.getParent(node);
            return this.getProperParentByIndentation(indentation, parent, textBuffer, currentLine, configuredIndentation, rootParent);
        }
        return node;
    }
    getParent(node) {
        return getParent(this.internalDocument, node);
    }
    constructor(lineCounter){
        super(null, []);
        this.lineCounter = lineCounter;
    }
};
var YAMLDocument = class {
    constructor(documents, tokens){
        this.documents = documents;
        this.tokens = tokens;
        this.errors = [];
        this.warnings = [];
    }
};
var YamlDocuments = class {
    /**
   * Get cached YAMLDocument
   * @param document TextDocument to parse
   * @param parserOptions YAML parserOptions
   * @param addRootObject if true and document is empty add empty object {} to force schema usage
   * @returns the YAMLDocument
   */ getYamlDocument(document2, parserOptions, addRootObject = false) {
        this.ensureCache(document2, parserOptions != null ? parserOptions : defaultOptions, addRootObject);
        return this.cache.get(document2.uri).document;
    }
    /**
   * For test purpose only!
   */ clear() {
        this.cache.clear();
    }
    ensureCache(document2, parserOptions, addRootObject) {
        const key = document2.uri;
        if (!this.cache.has(key)) {
            this.cache.set(key, {
                version: -1,
                document: new YAMLDocument([], []),
                parserOptions: defaultOptions
            });
        }
        const cacheEntry = this.cache.get(key);
        if (cacheEntry.version !== document2.version || parserOptions.customTags && !isArrayEqual(cacheEntry.parserOptions.customTags, parserOptions.customTags)) {
            let text = document2.getText();
            if (addRootObject && !/\S/.test(text)) {
                text = `{${text}}`;
            }
            const doc = parse5(text, parserOptions, document2);
            cacheEntry.document = doc;
            cacheEntry.version = document2.version;
            cacheEntry.parserOptions = parserOptions;
        }
    }
    constructor(){
        this.cache = /* @__PURE__ */ new Map();
    }
};
var yamlDocumentsCache = new YamlDocuments();
function YAMLErrorToYamlDocDiagnostics(error) {
    return {
        message: error.message,
        location: {
            start: error.pos[0],
            end: error.pos[1],
            toLineEnd: true
        },
        severity: 1,
        code: ErrorCode.Undefined
    };
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/parser/custom-tag-provider.js
var CommonTagImpl = class {
    get collection() {
        if (this.type === "mapping") {
            return "map";
        }
        if (this.type === "sequence") {
            return "seq";
        }
        return void 0;
    }
    resolve(value1) {
        if (isMap(value1) && this.type === "mapping") {
            return value1;
        }
        if (isSeq(value1) && this.type === "sequence") {
            return value1;
        }
        if (typeof value1 === "string" && this.type === "scalar") {
            return value1;
        }
    }
    constructor(tag, type){
        this.tag = tag;
        this.type = type;
    }
};
var IncludeTag = class {
    resolve(value1, onError) {
        if (value1 && value1.length > 0 && value1.trim()) {
            return value1;
        }
        onError("!include without value");
    }
    constructor(){
        this.tag = "!include";
        this.type = "scalar";
    }
};
function getCustomTags(customTags) {
    const tags = [];
    const filteredTags = filterInvalidCustomTags(customTags);
    for (const tag of filteredTags){
        const typeInfo = tag.split(" ");
        const tagName = typeInfo[0];
        const tagType = typeInfo[1] && typeInfo[1].toLowerCase() || "scalar";
        tags.push(new CommonTagImpl(tagName, tagType));
    }
    tags.push(new IncludeTag());
    return tags;
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/utils/textBuffer.js
var import_vscode_languageserver_types3 = __toESM(require_main());
var TextBuffer = class {
    getLineCount() {
        return this.doc.lineCount;
    }
    getLineLength(lineNumber) {
        const lineOffsets = this.doc.getLineOffsets();
        if (lineNumber >= lineOffsets.length) {
            return this.doc.getText().length;
        } else if (lineNumber < 0) {
            return 0;
        }
        const nextLineOffset = lineNumber + 1 < lineOffsets.length ? lineOffsets[lineNumber + 1] : this.doc.getText().length;
        return nextLineOffset - lineOffsets[lineNumber];
    }
    getLineContent(lineNumber) {
        const lineOffsets = this.doc.getLineOffsets();
        if (lineNumber >= lineOffsets.length) {
            return this.doc.getText();
        } else if (lineNumber < 0) {
            return "";
        }
        const nextLineOffset = lineNumber + 1 < lineOffsets.length ? lineOffsets[lineNumber + 1] : this.doc.getText().length;
        return this.doc.getText().substring(lineOffsets[lineNumber], nextLineOffset);
    }
    getLineCharCode(lineNumber, index) {
        return this.doc.getText(import_vscode_languageserver_types3.Range.create(lineNumber - 1, index, lineNumber - 1, index + 1)).charCodeAt(0);
    }
    getText(range) {
        return this.doc.getText(range);
    }
    getPosition(offest) {
        return this.doc.positionAt(offest);
    }
    constructor(doc){
        this.doc = doc;
    }
};
// ../../node_modules/yaml-language-server/lib/esm/languageservice/parser/yamlParser07.js
var defaultOptions = {
    customTags: [],
    yamlVersion: "1.2"
};
function parse5(text, parserOptions = defaultOptions, document2) {
    var _a;
    const options = {
        strict: false,
        customTags: getCustomTags(parserOptions.customTags),
        version: (_a = parserOptions.yamlVersion) != null ? _a : defaultOptions.yamlVersion,
        keepSourceTokens: true
    };
    const composer = new Composer(options);
    const lineCounter = new LineCounter();
    let isLastLineEmpty = false;
    if (document2) {
        const textBuffer = new TextBuffer(document2);
        const position = textBuffer.getPosition(text.length);
        const lineContent = textBuffer.getLineContent(position.line);
        isLastLineEmpty = lineContent.trim().length === 0;
    }
    const parser2 = isLastLineEmpty ? new Parser() : new Parser(lineCounter.addNewLine);
    const tokens = parser2.parse(text);
    const tokensArr = Array.from(tokens);
    const docs = composer.compose(tokensArr, true, text.length);
    const yamlDocs = Array.from(docs, (doc)=>parsedDocToSingleYAMLDocument(doc, lineCounter));
    return new YAMLDocument(yamlDocs, tokensArr);
}
function parsedDocToSingleYAMLDocument(parsedDoc, lineCounter) {
    const syd = new SingleYAMLDocument(lineCounter);
    syd.internalDocument = parsedDoc;
    return syd;
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/modelineUtil.js
function getSchemaFromModeline(doc) {
    if (doc instanceof SingleYAMLDocument) {
        const yamlLanguageServerModeline = doc.lineComments.find((lineComment2)=>{
            return isModeline(lineComment2);
        });
        if (yamlLanguageServerModeline != void 0) {
            const schemaMatchs = yamlLanguageServerModeline.match(/\$schema=\S+/g);
            if (schemaMatchs !== null && schemaMatchs.length >= 1) {
                if (schemaMatchs.length >= 2) {
                    console.log("Several $schema attributes have been found on the yaml-language-server modeline. The first one will be picked.");
                }
                return schemaMatchs[0].substring("$schema=".length);
            }
        }
    }
    return void 0;
}
function isModeline(lineText) {
    const matchModeline = lineText.match(/^#\s+yaml-language-server\s*:/g);
    return matchModeline !== null && matchModeline.length === 1;
}
// src/fillers/ajv.js
var AJVStub = class {
    compile() {
        return ()=>true;
    }
};
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlSchemaService.js
var localize8 = loadMessageBundle();
var ajv = new AJVStub();
var jsonSchema07 = require_json_schema_draft_07();
var schema07Validator = ajv.compile(jsonSchema07);
var MODIFICATION_ACTIONS;
(function(MODIFICATION_ACTIONS2) {
    MODIFICATION_ACTIONS2[MODIFICATION_ACTIONS2["delete"] = 0] = "delete";
    MODIFICATION_ACTIONS2[MODIFICATION_ACTIONS2["add"] = 1] = "add";
    MODIFICATION_ACTIONS2[MODIFICATION_ACTIONS2["deleteAll"] = 2] = "deleteAll";
})(MODIFICATION_ACTIONS || (MODIFICATION_ACTIONS = {}));
var FilePatternAssociation2 = class {
    addSchema(id) {
        this.schemas.push(id);
    }
    matchesPattern(fileName) {
        return this.patternRegExp && this.patternRegExp.test(fileName);
    }
    getSchemas() {
        return this.schemas;
    }
    constructor(pattern){
        try {
            this.patternRegExp = new RegExp(convertSimple2RegExpPattern(pattern) + "$");
        } catch (e) {
            this.patternRegExp = null;
        }
        this.schemas = [];
    }
};
var YAMLSchemaService = class extends JSONSchemaService {
    registerCustomSchemaProvider(customSchemaProvider) {
        this.customSchemaProvider = customSchemaProvider;
    }
    getAllSchemas() {
        const result = [];
        const schemaUris = /* @__PURE__ */ new Set();
        for (const filePattern of this.filePatternAssociations){
            const schemaUri = filePattern.uris[0];
            if (schemaUris.has(schemaUri)) {
                continue;
            }
            schemaUris.add(schemaUri);
            const schemaHandle = {
                uri: schemaUri,
                fromStore: false,
                usedForCurrentFile: false
            };
            if (this.schemaUriToNameAndDescription.has(schemaUri)) {
                const { name, description, versions } = this.schemaUriToNameAndDescription.get(schemaUri);
                schemaHandle.name = name;
                schemaHandle.description = description;
                schemaHandle.fromStore = true;
                schemaHandle.versions = versions;
            }
            result.push(schemaHandle);
        }
        return result;
    }
    async resolveSchemaContent(schemaToResolve, schemaURL, dependencies) {
        const resolveErrors = schemaToResolve.errors.slice(0);
        let schema4 = schemaToResolve.schema;
        const contextService = this.contextService;
        if (!schema07Validator(schema4)) {
            const errs = [];
            for (const err of schema07Validator.errors){
                errs.push(`${err.instancePath} : ${err.message}`);
            }
            resolveErrors.push(`Schema '${getSchemaTitle(schemaToResolve.schema, schemaURL)}' is not valid:
${errs.join("\n")}`);
        }
        const findSection = (schema5, path5)=>{
            if (!path5) {
                return schema5;
            }
            let current = schema5;
            if (path5[0] === "/") {
                path5 = path5.substr(1);
            }
            path5.split("/").some((part)=>{
                current = current[part];
                return !current;
            });
            return current;
        };
        const merge = (target, sourceRoot, sourceURI, path5)=>{
            const section = findSection(sourceRoot, path5);
            if (section) {
                for(const key in section){
                    if (Object.prototype.hasOwnProperty.call(section, key) && !Object.prototype.hasOwnProperty.call(target, key)) {
                        target[key] = section[key];
                    }
                }
            } else {
                resolveErrors.push(localize8("json.schema.invalidref", "$ref '{0}' in '{1}' can not be resolved.", path5, sourceURI));
            }
        };
        const resolveExternalLink = (node, uri, linkPath, parentSchemaURL, parentSchemaDependencies)=>{
            if (contextService && !/^\w+:\/\/.*/.test(uri)) {
                uri = contextService.resolveRelativePath(uri, parentSchemaURL);
            }
            uri = this.normalizeId(uri);
            const referencedHandle = this.getOrAddSchemaHandle(uri);
            return referencedHandle.getUnresolvedSchema().then((unresolvedSchema)=>{
                parentSchemaDependencies[uri] = true;
                if (unresolvedSchema.errors.length) {
                    const loc = linkPath ? uri + "#" + linkPath : uri;
                    resolveErrors.push(localize8("json.schema.problemloadingref", "Problems loading reference '{0}': {1}", loc, unresolvedSchema.errors[0]));
                }
                merge(node, unresolvedSchema.schema, uri, linkPath);
                node.url = uri;
                return resolveRefs(node, unresolvedSchema.schema, uri, referencedHandle.dependencies);
            });
        };
        const resolveRefs = async (node, parentSchema, parentSchemaURL, parentSchemaDependencies)=>{
            if (!node || typeof node !== "object") {
                return null;
            }
            const toWalk = [
                node
            ];
            const seen = [];
            const openPromises = [];
            const collectEntries = (...entries)=>{
                for (const entry of entries){
                    if (typeof entry === "object") {
                        toWalk.push(entry);
                    }
                }
            };
            const collectMapEntries = (...maps)=>{
                for (const map2 of maps){
                    if (typeof map2 === "object") {
                        for(const key in map2){
                            const entry = map2[key];
                            if (typeof entry === "object") {
                                toWalk.push(entry);
                            }
                        }
                    }
                }
            };
            const collectArrayEntries = (...arrays)=>{
                for (const array of arrays){
                    if (Array.isArray(array)) {
                        for (const entry of array){
                            if (typeof entry === "object") {
                                toWalk.push(entry);
                            }
                        }
                    }
                }
            };
            const handleRef = (next)=>{
                const seenRefs = [];
                while(next.$ref){
                    const ref = next.$ref;
                    const segments = ref.split("#", 2);
                    next._$ref = next.$ref;
                    delete next.$ref;
                    if (segments[0].length > 0) {
                        openPromises.push(resolveExternalLink(next, segments[0], segments[1], parentSchemaURL, parentSchemaDependencies));
                        return;
                    } else {
                        if (seenRefs.indexOf(ref) === -1) {
                            merge(next, parentSchema, parentSchemaURL, segments[1]);
                            seenRefs.push(ref);
                        }
                    }
                }
                collectEntries(next.items, next.additionalItems, next.additionalProperties, next.not, next.contains, next.propertyNames, next.if, next.then, next.else);
                collectMapEntries(next.definitions, next.properties, next.patternProperties, next.dependencies);
                collectArrayEntries(next.anyOf, next.allOf, next.oneOf, next.items, next.schemaSequence);
            };
            if (parentSchemaURL.indexOf("#") > 0) {
                const segments = parentSchemaURL.split("#", 2);
                if (segments[0].length > 0 && segments[1].length > 0) {
                    const newSchema = {};
                    await resolveExternalLink(newSchema, segments[0], segments[1], parentSchemaURL, parentSchemaDependencies);
                    for(const key in schema4){
                        if (key === "required") {
                            continue;
                        }
                        if (Object.prototype.hasOwnProperty.call(schema4, key) && !Object.prototype.hasOwnProperty.call(newSchema, key)) {
                            newSchema[key] = schema4[key];
                        }
                    }
                    schema4 = newSchema;
                }
            }
            while(toWalk.length){
                const next = toWalk.pop();
                if (seen.indexOf(next) >= 0) {
                    continue;
                }
                seen.push(next);
                handleRef(next);
            }
            return Promise.all(openPromises);
        };
        await resolveRefs(schema4, schema4, schemaURL, dependencies);
        return new ResolvedSchema(schema4, resolveErrors);
    }
    getSchemaForResource(resource, doc) {
        const resolveModelineSchema = ()=>{
            let schemaFromModeline = getSchemaFromModeline(doc);
            if (schemaFromModeline !== void 0) {
                if (!schemaFromModeline.startsWith("file:") && !schemaFromModeline.startsWith("http")) {
                    let appendix = "";
                    if (schemaFromModeline.indexOf("#") > 0) {
                        const segments = schemaFromModeline.split("#", 2);
                        schemaFromModeline = segments[0];
                        appendix = segments[1];
                    }
                    if (!path2.isAbsolute(schemaFromModeline)) {
                        const resUri = yaml_service_URI.parse(resource);
                        schemaFromModeline = yaml_service_URI.file(path2.resolve(path2.parse(resUri.fsPath).dir, schemaFromModeline)).toString();
                    } else {
                        schemaFromModeline = yaml_service_URI.file(schemaFromModeline).toString();
                    }
                    if (appendix.length > 0) {
                        schemaFromModeline += "#" + appendix;
                    }
                }
                return schemaFromModeline;
            }
        };
        const resolveSchemaForResource = (schemas2)=>{
            const schemaHandle = super.createCombinedSchema(resource, schemas2);
            return schemaHandle.getResolvedSchema().then((schema4)=>{
                if (schema4.schema && typeof schema4.schema === "object") {
                    schema4.schema.url = schemaHandle.url;
                }
                if (schema4.schema && schema4.schema.schemaSequence && schema4.schema.schemaSequence[doc.currentDocIndex]) {
                    return new ResolvedSchema(schema4.schema.schemaSequence[doc.currentDocIndex]);
                }
                return schema4;
            });
        };
        const resolveSchema = ()=>{
            const seen = /* @__PURE__ */ Object.create(null);
            const schemas2 = [];
            for (const entry of this.filePatternAssociations){
                if (entry.matchesPattern(resource)) {
                    for (const schemaId of entry.getURIs()){
                        if (!seen[schemaId]) {
                            schemas2.push(schemaId);
                            seen[schemaId] = true;
                        }
                    }
                }
            }
            if (schemas2.length > 0) {
                const highestPrioSchemas = this.highestPrioritySchemas(schemas2);
                return resolveSchemaForResource(highestPrioSchemas);
            }
            return Promise.resolve(null);
        };
        const modelineSchema = resolveModelineSchema();
        if (modelineSchema) {
            return resolveSchemaForResource([
                modelineSchema
            ]);
        }
        if (this.customSchemaProvider) {
            return this.customSchemaProvider(resource).then((schemaUri)=>{
                if (Array.isArray(schemaUri)) {
                    if (schemaUri.length === 0) {
                        return resolveSchema();
                    }
                    return Promise.all(schemaUri.map((schemaUri2)=>{
                        return this.resolveCustomSchema(schemaUri2, doc);
                    })).then((schemas2)=>{
                        return {
                            errors: [],
                            schema: {
                                allOf: schemas2.map((schemaObj)=>{
                                    return schemaObj.schema;
                                })
                            }
                        };
                    }, ()=>{
                        return resolveSchema();
                    });
                }
                if (!schemaUri) {
                    return resolveSchema();
                }
                return this.resolveCustomSchema(schemaUri, doc);
            }).then((schema4)=>{
                return schema4;
            }, ()=>{
                return resolveSchema();
            });
        } else {
            return resolveSchema();
        }
    }
    // Set the priority of a schema in the schema service
    addSchemaPriority(uri, priority) {
        let currSchemaArray = this.schemaPriorityMapping.get(uri);
        if (currSchemaArray) {
            currSchemaArray = currSchemaArray.add(priority);
            this.schemaPriorityMapping.set(uri, currSchemaArray);
        } else {
            this.schemaPriorityMapping.set(uri, /* @__PURE__ */ new Set().add(priority));
        }
    }
    /**
   * Search through all the schemas and find the ones with the highest priority
   */ highestPrioritySchemas(schemas2) {
        let highestPrio = 0;
        const priorityMapping = /* @__PURE__ */ new Map();
        schemas2.forEach((schema4)=>{
            const priority = this.schemaPriorityMapping.get(schema4) || [
                0
            ];
            priority.forEach((prio)=>{
                if (prio > highestPrio) {
                    highestPrio = prio;
                }
                let currPriorityArray = priorityMapping.get(prio);
                if (currPriorityArray) {
                    currPriorityArray = currPriorityArray.concat(schema4);
                    priorityMapping.set(prio, currPriorityArray);
                } else {
                    priorityMapping.set(prio, [
                        schema4
                    ]);
                }
            });
        });
        return priorityMapping.get(highestPrio) || [];
    }
    async resolveCustomSchema(schemaUri, doc) {
        const unresolvedSchema = await this.loadSchema(schemaUri);
        const schema4 = await this.resolveSchemaContent(unresolvedSchema, schemaUri, []);
        if (schema4.schema && typeof schema4.schema === "object") {
            schema4.schema.url = schemaUri;
        }
        if (schema4.schema && schema4.schema.schemaSequence && schema4.schema.schemaSequence[doc.currentDocIndex]) {
            return new ResolvedSchema(schema4.schema.schemaSequence[doc.currentDocIndex], schema4.errors);
        }
        return schema4;
    }
    /**
   * Save a schema with schema ID and schema content.
   * Overrides previous schemas set for that schema ID.
   */ async saveSchema(schemaId, schemaContent) {
        const id = this.normalizeId(schemaId);
        this.getOrAddSchemaHandle(id, schemaContent);
        this.schemaPriorityMapping.set(id, /* @__PURE__ */ new Set().add(SchemaPriority.Settings));
        return Promise.resolve(void 0);
    }
    /**
   * Delete schemas on specific path
   */ async deleteSchemas(deletions) {
        deletions.schemas.forEach((s)=>{
            this.deleteSchema(s);
        });
        return Promise.resolve(void 0);
    }
    /**
   * Delete a schema with schema ID.
   */ async deleteSchema(schemaId) {
        const id = this.normalizeId(schemaId);
        if (this.schemasById[id]) {
            delete this.schemasById[id];
        }
        this.schemaPriorityMapping.delete(id);
        return Promise.resolve(void 0);
    }
    /**
   * Add content to a specified schema at a specified path
   */ async addContent(additions) {
        const schema4 = await this.getResolvedSchema(additions.schema);
        if (schema4) {
            const resolvedSchemaLocation = this.resolveJSONSchemaToSection(schema4.schema, additions.path);
            if (typeof resolvedSchemaLocation === "object") {
                resolvedSchemaLocation[additions.key] = additions.content;
            }
            await this.saveSchema(additions.schema, schema4.schema);
        }
    }
    /**
   * Delete content in a specified schema at a specified path
   */ async deleteContent(deletions) {
        const schema4 = await this.getResolvedSchema(deletions.schema);
        if (schema4) {
            const resolvedSchemaLocation = this.resolveJSONSchemaToSection(schema4.schema, deletions.path);
            if (typeof resolvedSchemaLocation === "object") {
                delete resolvedSchemaLocation[deletions.key];
            }
            await this.saveSchema(deletions.schema, schema4.schema);
        }
    }
    /**
   * Take a JSON Schema and the path that you would like to get to
   * @returns the JSON Schema resolved at that specific path
   */ resolveJSONSchemaToSection(schema4, paths) {
        const splitPathway = paths.split("/");
        let resolvedSchemaLocation = schema4;
        for (const path5 of splitPathway){
            if (path5 === "") {
                continue;
            }
            this.resolveNext(resolvedSchemaLocation, path5);
            resolvedSchemaLocation = resolvedSchemaLocation[path5];
        }
        return resolvedSchemaLocation;
    }
    /**
   * Resolve the next Object if they have compatible types
   * @param object a location in the JSON Schema
   * @param token the next token that you want to search for
   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
    resolveNext(object, token) {
        if (Array.isArray(object) && isNaN(token)) {
            throw new Error("Expected a number after the array object");
        } else if (typeof object === "object" && typeof token !== "string") {
            throw new Error("Expected a string after the object");
        }
    }
    /**
   * Everything below here is needed because we're importing from vscode-json-languageservice umd and we need
   * to provide a wrapper around the javascript methods we are calling since they have no type
   */ normalizeId(id) {
        try {
            return yaml_service_URI.parse(id).toString();
        } catch (e) {
            return id;
        }
    }
    /*
   * Everything below here is needed because we're importing from vscode-json-languageservice umd and we need
   * to provide a wrapper around the javascript methods we are calling since they have no type
   */ getOrAddSchemaHandle(id, unresolvedSchemaContent) {
        return super.getOrAddSchemaHandle(id, unresolvedSchemaContent);
    }
    loadSchema(schemaUri) {
        const requestService = this.requestService;
        return super.loadSchema(schemaUri).then((unresolvedJsonSchema)=>{
            if (unresolvedJsonSchema.errors && unresolvedJsonSchema.schema === void 0) {
                return requestService(schemaUri).then((content)=>{
                    if (!content) {
                        const errorMessage = localize8("json.schema.nocontent", "Unable to load schema from '{0}': No content. {1}", toDisplayString2(schemaUri), unresolvedJsonSchema.errors);
                        return new UnresolvedSchema({}, [
                            errorMessage
                        ]);
                    }
                    try {
                        const schemaContent = parse3(content);
                        return new UnresolvedSchema(schemaContent, []);
                    } catch (yamlError) {
                        const errorMessage = localize8("json.schema.invalidFormat", "Unable to parse content from '{0}': {1}.", toDisplayString2(schemaUri), yamlError);
                        return new UnresolvedSchema({}, [
                            errorMessage
                        ]);
                    }
                }, // eslint-disable-next-line @typescript-eslint/no-explicit-any
                (error)=>{
                    let errorMessage = error.toString();
                    const errorSplit = error.toString().split("Error: ");
                    if (errorSplit.length > 1) {
                        errorMessage = errorSplit[1];
                    }
                    return new UnresolvedSchema({}, [
                        errorMessage
                    ]);
                });
            }
            unresolvedJsonSchema.uri = schemaUri;
            if (this.schemaUriToNameAndDescription.has(schemaUri)) {
                const { name, description, versions } = this.schemaUriToNameAndDescription.get(schemaUri);
                unresolvedJsonSchema.schema.title = name != null ? name : unresolvedJsonSchema.schema.title;
                unresolvedJsonSchema.schema.description = description != null ? description : unresolvedJsonSchema.schema.description;
                unresolvedJsonSchema.schema.versions = versions != null ? versions : unresolvedJsonSchema.schema.versions;
            }
            return unresolvedJsonSchema;
        });
    }
    registerExternalSchema(uri, filePatterns, unresolvedSchema, name, description, versions) {
        if (name || description) {
            this.schemaUriToNameAndDescription.set(uri, {
                name,
                description,
                versions
            });
        }
        return super.registerExternalSchema(uri, filePatterns, unresolvedSchema);
    }
    clearExternalSchemas() {
        super.clearExternalSchemas();
    }
    setSchemaContributions(schemaContributions2) {
        super.setSchemaContributions(schemaContributions2);
    }
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    getRegisteredSchemaIds(filter) {
        return super.getRegisteredSchemaIds(filter);
    }
    getResolvedSchema(schemaId) {
        return super.getResolvedSchema(schemaId);
    }
    onResourceChange(uri) {
        return super.onResourceChange(uri);
    }
    constructor(requestService, contextService, promiseConstructor){
        super(requestService, contextService, promiseConstructor);
        this.schemaUriToNameAndDescription = /* @__PURE__ */ new Map();
        this.customSchemaProvider = void 0;
        this.requestService = requestService;
        this.schemaPriorityMapping = /* @__PURE__ */ new Map();
    }
};
function toDisplayString2(url) {
    try {
        const uri = yaml_service_URI.parse(url);
        if (uri.scheme === "file") {
            return uri.fsPath;
        }
    } catch (e) {}
    return url;
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/documentSymbols.js
var YAMLDocumentSymbols = class {
    findDocumentSymbols(document2, context = {
        resultLimit: Number.MAX_VALUE
    }) {
        var _a;
        let results = [];
        try {
            const doc = yamlDocumentsCache.getYamlDocument(document2);
            if (!doc || doc["documents"].length === 0) {
                return null;
            }
            for (const yamlDoc of doc["documents"]){
                if (yamlDoc.root) {
                    results = results.concat(this.jsonDocumentSymbols.findDocumentSymbols(document2, yamlDoc, context));
                }
            }
        } catch (err) {
            (_a = this.telemetry) == null ? void 0 : _a.sendError("yaml.documentSymbols.error", {
                error: convertErrorToTelemetryMsg(err)
            });
        }
        return results;
    }
    findHierarchicalDocumentSymbols(document2, context = {
        resultLimit: Number.MAX_VALUE
    }) {
        var _a;
        let results = [];
        try {
            const doc = yamlDocumentsCache.getYamlDocument(document2);
            if (!doc || doc["documents"].length === 0) {
                return null;
            }
            for (const yamlDoc of doc["documents"]){
                if (yamlDoc.root) {
                    results = results.concat(this.jsonDocumentSymbols.findDocumentSymbols2(document2, yamlDoc, context));
                }
            }
        } catch (err) {
            (_a = this.telemetry) == null ? void 0 : _a.sendError("yaml.hierarchicalDocumentSymbols.error", {
                error: convertErrorToTelemetryMsg(err)
            });
        }
        return results;
    }
    constructor(schemaService, telemetry){
        this.telemetry = telemetry;
        this.jsonDocumentSymbols = new JSONDocumentSymbols(schemaService);
        this.jsonDocumentSymbols.getKeyLabel = (property)=>{
            const keyNode = property.keyNode.internalNode;
            let name = "";
            if (isMap(keyNode)) {
                name = "{}";
            } else if (isSeq(keyNode)) {
                name = "[]";
            } else {
                name = keyNode.source;
            }
            return name;
        };
    }
};
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlHover.js
var import_vscode_languageserver_types4 = __toESM(require_main());
// ../../node_modules/yaml-language-server/lib/esm/languageservice/parser/isKubernetes.js
function setKubernetesParserOption(jsonDocuments, option) {
    for (const jsonDoc of jsonDocuments){
        jsonDoc.isKubernetes = option;
    }
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlHover.js
var path3 = __toESM(require_path_browserify());
var YAMLHover = class {
    configure(languageSettings) {
        if (languageSettings) {
            this.shouldHover = languageSettings.hover;
            this.indentation = languageSettings.indentation;
        }
    }
    doHover(document2, position, isKubernetes = false) {
        var _a;
        try {
            if (!this.shouldHover || !document2) {
                return Promise.resolve(void 0);
            }
            const doc = yamlDocumentsCache.getYamlDocument(document2);
            const offset = document2.offsetAt(position);
            const currentDoc = matchOffsetToDocument(offset, doc);
            if (currentDoc === null) {
                return Promise.resolve(void 0);
            }
            setKubernetesParserOption(doc.documents, isKubernetes);
            const currentDocIndex = doc.documents.indexOf(currentDoc);
            currentDoc.currentDocIndex = currentDocIndex;
            return this.getHover(document2, position, currentDoc);
        } catch (error) {
            (_a = this.telemetry) == null ? void 0 : _a.sendError("yaml.hover.error", {
                error: convertErrorToTelemetryMsg(error)
            });
        }
    }
    // method copied from https://github.com/microsoft/vscode-json-languageservice/blob/2ea5ad3d2ffbbe40dea11cfe764a502becf113ce/src/services/jsonHover.ts#L23
    getHover(document2, position, doc) {
        const offset = document2.offsetAt(position);
        let node = doc.getNodeFromOffset(offset);
        if (!node || (node.type === "object" || node.type === "array") && offset > node.offset + 1 && offset < node.offset + node.length - 1) {
            return Promise.resolve(null);
        }
        const hoverRangeNode = node;
        if (node.type === "string") {
            const parent = node.parent;
            if (parent && parent.type === "property" && parent.keyNode === node) {
                node = parent.valueNode;
                if (!node) {
                    return Promise.resolve(null);
                }
            }
        }
        const hoverRange = import_vscode_languageserver_types4.Range.create(document2.positionAt(hoverRangeNode.offset), document2.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
        const createHover = (contents)=>{
            if (this.indentation !== void 0) {
                const indentationMatchRegex = new RegExp(` {${this.indentation.length}}`, "g");
                contents = contents.replace(indentationMatchRegex, "&emsp;");
            }
            const markupContent = {
                kind: import_vscode_languageserver_types4.MarkupKind.Markdown,
                value: contents
            };
            const result = {
                contents: markupContent,
                range: hoverRange
            };
            return result;
        };
        const removePipe = (value1)=>{
            return value1.replace(/\|\|\s*$/, "");
        };
        return this.schemaService.getSchemaForResource(document2.uri, doc).then((schema4)=>{
            if (schema4 && node && !schema4.errors.length) {
                const matchingSchemas = doc.getMatchingSchemas(schema4.schema, node.offset);
                let title = void 0;
                let markdownDescription = void 0;
                let markdownEnumValueDescription = void 0;
                let enumValue = void 0;
                const markdownExamples = [];
                matchingSchemas.every((s)=>{
                    if ((s.node === node || node.type === "property" && node.valueNode === s.node) && !s.inverted && s.schema) {
                        title = title || s.schema.title || s.schema.closestTitle;
                        markdownDescription = markdownDescription || s.schema.markdownDescription || toMarkdown2(s.schema.description);
                        if (s.schema.enum) {
                            const idx = s.schema.enum.indexOf(getNodeValue4(node));
                            if (s.schema.markdownEnumDescriptions) {
                                markdownEnumValueDescription = s.schema.markdownEnumDescriptions[idx];
                            } else if (s.schema.enumDescriptions) {
                                markdownEnumValueDescription = toMarkdown2(s.schema.enumDescriptions[idx]);
                            }
                            if (markdownEnumValueDescription) {
                                enumValue = s.schema.enum[idx];
                                if (typeof enumValue !== "string") {
                                    enumValue = JSON.stringify(enumValue);
                                }
                            }
                        }
                        if (s.schema.anyOf && isAllSchemasMatched(node, matchingSchemas, s.schema)) {
                            title = "";
                            markdownDescription = "";
                            s.schema.anyOf.forEach((childSchema, index)=>{
                                title += childSchema.title || s.schema.closestTitle || "";
                                markdownDescription += childSchema.markdownDescription || toMarkdown2(childSchema.description) || "";
                                if (index !== s.schema.anyOf.length - 1) {
                                    title += " || ";
                                    markdownDescription += " || ";
                                }
                            });
                            title = removePipe(title);
                            markdownDescription = removePipe(markdownDescription);
                        }
                        if (s.schema.examples) {
                            s.schema.examples.forEach((example)=>{
                                markdownExamples.push(JSON.stringify(example, null, 2));
                            });
                        }
                    }
                    return true;
                });
                let result = "";
                if (title) {
                    result = "#### " + toMarkdown2(title);
                }
                if (markdownDescription) {
                    if (result.length > 0) {
                        result += "\n\n";
                    }
                    result += markdownDescription;
                }
                if (markdownEnumValueDescription) {
                    if (result.length > 0) {
                        result += "\n\n";
                    }
                    result += `\`${toMarkdownCodeBlock2(enumValue)}\`: ${markdownEnumValueDescription}`;
                }
                if (markdownExamples.length !== 0) {
                    if (result.length > 0) {
                        result += "\n\n";
                    }
                    result += "Examples:";
                    markdownExamples.forEach((example)=>{
                        result += `

\`\`\`${example}\`\`\``;
                    });
                }
                if (result.length > 0 && schema4.schema.url) {
                    result += `

Source: [${getSchemaName(schema4.schema)}](${schema4.schema.url})`;
                }
                return createHover(result);
            }
            return null;
        });
    }
    constructor(schemaService, telemetry){
        this.telemetry = telemetry;
        this.shouldHover = true;
        this.schemaService = schemaService;
    }
};
function getSchemaName(schema4) {
    let result = "JSON Schema";
    const urlString = schema4.url;
    if (urlString) {
        const url = yaml_service_URI.parse(urlString);
        result = path3.basename(url.fsPath);
    } else if (schema4.title) {
        result = schema4.title;
    }
    return result;
}
function toMarkdown2(plain) {
    if (plain) {
        const res = plain.replace(/([^\n\r])(\r?\n)([^\n\r])/gm, "$1\n\n$3");
        return res.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
    }
    return void 0;
}
function toMarkdownCodeBlock2(content) {
    if (content.indexOf("`") !== -1) {
        return "`` " + content + " ``";
    }
    return content;
}
function isAllSchemasMatched(node, matchingSchemas, schema4) {
    let count = 0;
    for (const matchSchema of matchingSchemas){
        if (node === matchSchema.node && matchSchema.schema !== schema4) {
            schema4.anyOf.forEach((childSchema)=>{
                if (matchSchema.schema.title === childSchema.title && matchSchema.schema.description === childSchema.description && matchSchema.schema.properties === childSchema.properties) {
                    count++;
                }
            });
        }
    }
    return count === schema4.anyOf.length;
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlValidation.js
var import_vscode_languageserver_types8 = __toESM(require_main());
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/validation/unused-anchors.js
var import_vscode_languageserver_types5 = __toESM(require_main());
var UnusedAnchorsValidator = class {
    validate(document2, yamlDoc) {
        const result = [];
        const anchors = /* @__PURE__ */ new Set();
        const usedAnchors = /* @__PURE__ */ new Set();
        const anchorParent = /* @__PURE__ */ new Map();
        visit2(yamlDoc.internalDocument, (key, node, path5)=>{
            if (!isNode(node)) {
                return;
            }
            if ((isCollection(node) || isScalar(node)) && node.anchor) {
                anchors.add(node);
                anchorParent.set(node, path5[path5.length - 1]);
            }
            if (isAlias(node)) {
                usedAnchors.add(node.resolve(yamlDoc.internalDocument));
            }
        });
        for (const anchor of anchors){
            if (!usedAnchors.has(anchor)) {
                const aToken = this.getAnchorNode(anchorParent.get(anchor), anchor);
                if (aToken) {
                    const range = import_vscode_languageserver_types5.Range.create(document2.positionAt(aToken.offset), document2.positionAt(aToken.offset + aToken.source.length));
                    const warningDiagnostic = import_vscode_languageserver_types5.Diagnostic.create(range, `Unused anchor "${aToken.source}"`, import_vscode_languageserver_types5.DiagnosticSeverity.Hint, 0);
                    warningDiagnostic.tags = [
                        import_vscode_languageserver_types5.DiagnosticTag.Unnecessary
                    ];
                    result.push(warningDiagnostic);
                }
            }
        }
        return result;
    }
    getAnchorNode(parentNode, node) {
        if (parentNode && parentNode.srcToken) {
            const token = parentNode.srcToken;
            if (isCollectionItem(token)) {
                return getAnchorFromCollectionItem(token);
            } else if (cst_exports.isCollection(token)) {
                for (const t1 of token.items){
                    if (node.srcToken !== t1.value) continue;
                    const anchor = getAnchorFromCollectionItem(t1);
                    if (anchor) {
                        return anchor;
                    }
                }
            }
        }
        return void 0;
    }
};
function getAnchorFromCollectionItem(token) {
    for (const t1 of token.start){
        if (t1.type === "anchor") {
            return t1;
        }
    }
    if (token.sep && Array.isArray(token.sep)) {
        for (const t1 of token.sep){
            if (t1.type === "anchor") {
                return t1;
            }
        }
    }
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/validation/yaml-style.js
var import_vscode_languageserver_types6 = __toESM(require_main());
var YAMLStyleValidator = class {
    validate(document2, yamlDoc) {
        const result = [];
        visit2(yamlDoc.internalDocument, (key, node)=>{
            var _a, _b;
            if (this.forbidMapping && isMap(node) && ((_a = node.srcToken) == null ? void 0 : _a.type) === "flow-collection") {
                result.push(import_vscode_languageserver_types6.Diagnostic.create(this.getRangeOf(document2, node.srcToken), "Flow style mapping is forbidden", import_vscode_languageserver_types6.DiagnosticSeverity.Error, "flowMap"));
            }
            if (this.forbidSequence && isSeq(node) && ((_b = node.srcToken) == null ? void 0 : _b.type) === "flow-collection") {
                result.push(import_vscode_languageserver_types6.Diagnostic.create(this.getRangeOf(document2, node.srcToken), "Flow style sequence is forbidden", import_vscode_languageserver_types6.DiagnosticSeverity.Error, "flowSeq"));
            }
        });
        return result;
    }
    getRangeOf(document2, node) {
        return import_vscode_languageserver_types6.Range.create(document2.positionAt(node.start.offset), document2.positionAt(node.end.pop().offset));
    }
    constructor(settings){
        this.forbidMapping = settings.flowMapping === "forbid";
        this.forbidSequence = settings.flowSequence === "forbid";
    }
};
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/validation/map-key-order.js
var import_vscode_languageserver_types7 = __toESM(require_main());
var MapKeyOrderValidator = class {
    validate(document2, yamlDoc) {
        const result = [];
        visit2(yamlDoc.internalDocument, (key, node)=>{
            if (isMap(node)) {
                for(let i = 1; i < node.items.length; i++){
                    if (compare(node.items[i - 1], node.items[i]) > 0) {
                        const range = createRange2(document2, node.items[i - 1]);
                        result.push(import_vscode_languageserver_types7.Diagnostic.create(range, `Wrong ordering of key "${node.items[i - 1].key}" in mapping`, import_vscode_languageserver_types7.DiagnosticSeverity.Error, "mapKeyOrder"));
                    }
                }
            }
        });
        return result;
    }
};
function createRange2(document2, node) {
    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
    const start = (_f = (_c = (_a = node == null ? void 0 : node.srcToken.start[0]) == null ? void 0 : _a.offset) != null ? _c : (_b = node == null ? void 0 : node.srcToken) == null ? void 0 : _b.key.offset) != null ? _f : (_e = (_d = node == null ? void 0 : node.srcToken) == null ? void 0 : _d.sep[0]) == null ? void 0 : _e.offset;
    const end = ((_g = node == null ? void 0 : node.srcToken) == null ? void 0 : _g.value.offset) || ((_i = (_h = node == null ? void 0 : node.srcToken) == null ? void 0 : _h.sep[0]) == null ? void 0 : _i.offset) || ((_j = node == null ? void 0 : node.srcToken) == null ? void 0 : _j.key.offset) || ((_k = node == null ? void 0 : node.srcToken.start[node.srcToken.start.length - 1]) == null ? void 0 : _k.offset);
    return import_vscode_languageserver_types7.Range.create(document2.positionAt(start), document2.positionAt(end));
}
function compare(thiz, that) {
    const thatKey = String(that.key);
    const thisKey = String(thiz.key);
    return thisKey.localeCompare(thatKey);
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlValidation.js
var yamlDiagToLSDiag = (yamlDiag, textDocument)=>{
    const start = textDocument.positionAt(yamlDiag.location.start);
    const range = {
        start,
        end: yamlDiag.location.toLineEnd ? import_vscode_languageserver_types8.Position.create(start.line, new TextBuffer(textDocument).getLineLength(start.line)) : textDocument.positionAt(yamlDiag.location.end)
    };
    return import_vscode_languageserver_types8.Diagnostic.create(range, yamlDiag.message, yamlDiag.severity, yamlDiag.code, YAML_SOURCE);
};
var YAMLValidation = class {
    configure(settings) {
        this.validators = [];
        if (settings) {
            this.validationEnabled = settings.validate;
            this.customTags = settings.customTags;
            this.disableAdditionalProperties = settings.disableAdditionalProperties;
            this.yamlVersion = settings.yamlVersion;
            if (settings.flowMapping === "forbid" || settings.flowSequence === "forbid") {
                this.validators.push(new YAMLStyleValidator(settings));
            }
            if (settings.keyOrdering) {
                this.validators.push(new MapKeyOrderValidator());
            }
        }
        this.validators.push(new UnusedAnchorsValidator());
    }
    async doValidation(textDocument, isKubernetes = false) {
        var _a;
        if (!this.validationEnabled) {
            return Promise.resolve([]);
        }
        const validationResult = [];
        try {
            const yamlDocument = yamlDocumentsCache.getYamlDocument(textDocument, {
                customTags: this.customTags,
                yamlVersion: this.yamlVersion
            }, true);
            let index = 0;
            for (const currentYAMLDoc of yamlDocument.documents){
                currentYAMLDoc.isKubernetes = isKubernetes;
                currentYAMLDoc.currentDocIndex = index;
                currentYAMLDoc.disableAdditionalProperties = this.disableAdditionalProperties;
                currentYAMLDoc.uri = textDocument.uri;
                const validation = await this.jsonValidation.doValidation(textDocument, currentYAMLDoc);
                const syd = currentYAMLDoc;
                if (syd.errors.length > 0) {
                    validationResult.push(...syd.errors);
                }
                if (syd.warnings.length > 0) {
                    validationResult.push(...syd.warnings);
                }
                validationResult.push(...validation);
                validationResult.push(...this.runAdditionalValidators(textDocument, currentYAMLDoc));
                index++;
            }
        } catch (err) {
            (_a = this.telemetry) == null ? void 0 : _a.sendError("yaml.validation.error", {
                error: convertErrorToTelemetryMsg(err)
            });
        }
        let previousErr;
        const foundSignatures = /* @__PURE__ */ new Set();
        const duplicateMessagesRemoved = [];
        for (let err of validationResult){
            if (isKubernetes && err.message === this.MATCHES_MULTIPLE) {
                continue;
            }
            if (Object.prototype.hasOwnProperty.call(err, "location")) {
                err = yamlDiagToLSDiag(err, textDocument);
            }
            if (!err.source) {
                err.source = YAML_SOURCE;
            }
            if (previousErr && previousErr.message === err.message && previousErr.range.end.line === err.range.start.line && Math.abs(previousErr.range.end.character - err.range.end.character) >= 1) {
                previousErr.range.end = err.range.end;
                continue;
            } else {
                previousErr = err;
            }
            const errSig = err.range.start.line + " " + err.range.start.character + " " + err.message;
            if (!foundSignatures.has(errSig)) {
                duplicateMessagesRemoved.push(err);
                foundSignatures.add(errSig);
            }
        }
        return duplicateMessagesRemoved;
    }
    runAdditionalValidators(document2, yarnDoc) {
        const result = [];
        for (const validator of this.validators){
            result.push(...validator.validate(document2, yarnDoc));
        }
        return result;
    }
    constructor(schemaService, telemetry){
        this.telemetry = telemetry;
        this.validators = [];
        this.MATCHES_MULTIPLE = "Matches multiple schemas when only one must validate.";
        this.validationEnabled = true;
        this.jsonValidation = new JSONValidation(schemaService, Promise);
    }
};
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlFormatter.js
var import_vscode_languageserver_types9 = __toESM(require_main());
var prettier = __toESM(require_standalone());
var parser = __toESM(require_parser_yaml());
var YAMLFormatter = class {
    configure(shouldFormat) {
        if (shouldFormat) {
            this.formatterEnabled = shouldFormat.format;
        }
    }
    format(document2, options) {
        if (!this.formatterEnabled) {
            return [];
        }
        try {
            const text = document2.getText();
            const prettierOptions = {
                parser: "yaml",
                plugins: [
                    parser
                ],
                // --- FormattingOptions ---
                tabWidth: options.tabWidth || options.tabSize,
                // --- CustomFormatterOptions ---
                singleQuote: options.singleQuote,
                bracketSpacing: options.bracketSpacing,
                // 'preserve' is the default for Options.proseWrap. See also server.ts
                proseWrap: "always" === options.proseWrap ? "always" : "never" === options.proseWrap ? "never" : "preserve",
                printWidth: options.printWidth
            };
            const formatted = prettier.format(text, prettierOptions);
            return [
                import_vscode_languageserver_types9.TextEdit.replace(import_vscode_languageserver_types9.Range.create(import_vscode_languageserver_types9.Position.create(0, 0), document2.positionAt(text.length)), formatted)
            ];
        } catch (error) {
            return [];
        }
    }
    constructor(){
        this.formatterEnabled = true;
    }
};
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlLinks.js
var YamlLinks = class {
    findLinks(document2) {
        var _a;
        try {
            const doc = yamlDocumentsCache.getYamlDocument(document2);
            const linkPromises = [];
            for (const yamlDoc of doc.documents){
                linkPromises.push(findLinks(document2, yamlDoc));
            }
            return Promise.all(linkPromises).then((yamlLinkArray)=>[].concat(...yamlLinkArray));
        } catch (err) {
            (_a = this.telemetry) == null ? void 0 : _a.sendError("yaml.documentLink.error", {
                error: convertErrorToTelemetryMsg(err)
            });
        }
    }
    constructor(telemetry){
        this.telemetry = telemetry;
    }
};
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlFolding.js
var import_vscode_languageserver_types10 = __toESM(require_main());
function getFoldingRanges2(document2, context) {
    if (!document2) {
        return;
    }
    const result = [];
    const doc = yamlDocumentsCache.getYamlDocument(document2);
    for (const ymlDoc of doc.documents){
        if (doc.documents.length > 1) {
            result.push(createNormalizedFolding(document2, ymlDoc.root));
        }
        ymlDoc.visit((node)=>{
            var _a;
            if (node.type === "object" && ((_a = node.parent) == null ? void 0 : _a.type) === "array") {
                result.push(createNormalizedFolding(document2, node));
            }
            if (node.type === "property" && node.valueNode) {
                switch(node.valueNode.type){
                    case "array":
                    case "object":
                        result.push(createNormalizedFolding(document2, node));
                        break;
                    case "string":
                        {
                            const nodePosn = document2.positionAt(node.offset);
                            const valuePosn = document2.positionAt(node.valueNode.offset + node.valueNode.length);
                            if (nodePosn.line !== valuePosn.line) {
                                result.push(createNormalizedFolding(document2, node));
                            }
                            break;
                        }
                    default:
                        return true;
                }
            }
            return true;
        });
    }
    const rangeLimit = context && context.rangeLimit;
    if (typeof rangeLimit !== "number" || result.length <= rangeLimit) {
        return result;
    }
    if (context && context.onRangeLimitExceeded) {
        context.onRangeLimitExceeded(document2.uri);
    }
    return result.slice(0, context.rangeLimit);
}
function createNormalizedFolding(document2, node) {
    const startPos = document2.positionAt(node.offset);
    let endPos = document2.positionAt(node.offset + node.length);
    const textFragment = document2.getText(import_vscode_languageserver_types10.Range.create(startPos, endPos));
    const newLength = textFragment.length - textFragment.trimRight().length;
    if (newLength > 0) {
        endPos = document2.positionAt(node.offset + node.length - newLength);
    }
    return import_vscode_languageserver_types10.FoldingRange.create(startPos.line, endPos.line, startPos.character, endPos.character);
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlCodeActions.js
var import_vscode_languageserver_types11 = __toESM(require_main());
// ../../node_modules/yaml-language-server/lib/esm/commands.js
var YamlCommands;
(function(YamlCommands2) {
    YamlCommands2["JUMP_TO_SCHEMA"] = "jumpToSchema";
})(YamlCommands || (YamlCommands = {}));
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlCodeActions.js
var path4 = __toESM(require_path_browserify());
// ../../node_modules/yaml-language-server/lib/esm/languageservice/utils/flow-style-rewriter.js
var FlowStyleRewriter = class {
    write(node) {
        if (node.internalNode.srcToken["type"] !== "flow-collection") {
            return null;
        }
        const collection = node.internalNode.srcToken;
        const blockType = collection.start.type === "flow-map-start" ? "block-map" : "block-seq";
        const parentType = node.parent.type;
        const blockStyle = {
            type: blockType,
            offset: collection.offset,
            indent: collection.indent,
            items: []
        };
        for (const item of collection.items){
            cst_exports.visit(item, ({ key, sep, value: value1 })=>{
                if (blockType === "block-map") {
                    const start = [
                        {
                            type: "space",
                            indent: 0,
                            offset: key.offset,
                            source: this.indentation
                        }
                    ];
                    if (parentType === "property") {
                        start.unshift({
                            type: "newline",
                            indent: 0,
                            offset: key.offset,
                            source: "\n"
                        });
                    }
                    blockStyle.items.push({
                        start,
                        key,
                        sep,
                        value: value1
                    });
                } else if (blockType === "block-seq") {
                    blockStyle.items.push({
                        start: [
                            {
                                type: "newline",
                                indent: 0,
                                offset: value1.offset,
                                source: "\n"
                            },
                            {
                                type: "space",
                                indent: 0,
                                offset: value1.offset,
                                source: this.indentation
                            },
                            {
                                type: "seq-item-ind",
                                indent: 0,
                                offset: value1.offset,
                                source: "-"
                            },
                            {
                                type: "space",
                                indent: 0,
                                offset: value1.offset,
                                source: " "
                            }
                        ],
                        value: value1
                    });
                }
                if (value1.type === "flow-collection") {
                    return visit2.SKIP;
                }
            });
        }
        return cst_exports.stringify(blockStyle);
    }
    constructor(indentation){
        this.indentation = indentation;
    }
};
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlCodeActions.js
var _ = __toESM(require_lodash());
var YamlCodeActions = class {
    configure(settings) {
        this.indentation = settings.indentation;
    }
    getCodeAction(document2, params) {
        if (!params.context.diagnostics) {
            return;
        }
        const result = [];
        result.push(...this.getConvertToBooleanActions(params.context.diagnostics, document2));
        result.push(...this.getJumpToSchemaActions(params.context.diagnostics));
        result.push(...this.getTabToSpaceConverting(params.context.diagnostics, document2));
        result.push(...this.getUnusedAnchorsDelete(params.context.diagnostics, document2));
        result.push(...this.getConvertToBlockStyleActions(params.context.diagnostics, document2));
        result.push(...this.getKeyOrderActions(params.context.diagnostics, document2));
        return result;
    }
    getJumpToSchemaActions(diagnostics) {
        var _a, _b, _c, _d, _e;
        const isOpenTextDocumentEnabled = (_d = (_c = (_b = (_a = this.clientCapabilities) == null ? void 0 : _a.window) == null ? void 0 : _b.showDocument) == null ? void 0 : _c.support) != null ? _d : false;
        if (!isOpenTextDocumentEnabled) {
            return [];
        }
        const schemaUriToDiagnostic = /* @__PURE__ */ new Map();
        for (const diagnostic of diagnostics){
            const schemaUri = ((_e = diagnostic.data) == null ? void 0 : _e.schemaUri) || [];
            for (const schemaUriStr of schemaUri){
                if (schemaUriStr) {
                    if (!schemaUriToDiagnostic.has(schemaUriStr)) {
                        schemaUriToDiagnostic.set(schemaUriStr, []);
                    }
                    schemaUriToDiagnostic.get(schemaUriStr).push(diagnostic);
                }
            }
        }
        const result = [];
        for (const schemaUri of schemaUriToDiagnostic.keys()){
            const action = import_vscode_languageserver_types11.CodeAction.create(`Jump to schema location (${path4.basename(schemaUri)})`, import_vscode_languageserver_types11.Command.create("JumpToSchema", YamlCommands.JUMP_TO_SCHEMA, schemaUri));
            action.diagnostics = schemaUriToDiagnostic.get(schemaUri);
            result.push(action);
        }
        return result;
    }
    getTabToSpaceConverting(diagnostics, document2) {
        const result = [];
        const textBuff = new TextBuffer(document2);
        const processedLine = [];
        for (const diag of diagnostics){
            if (diag.message === "Using tabs can lead to unpredictable results") {
                if (processedLine.includes(diag.range.start.line)) {
                    continue;
                }
                const lineContent = textBuff.getLineContent(diag.range.start.line);
                let replacedTabs = 0;
                let newText = "";
                for(let i = diag.range.start.character; i <= diag.range.end.character; i++){
                    const char = lineContent.charAt(i);
                    if (char !== "	") {
                        break;
                    }
                    replacedTabs++;
                    newText += this.indentation;
                }
                processedLine.push(diag.range.start.line);
                let resultRange = diag.range;
                if (replacedTabs !== diag.range.end.character - diag.range.start.character) {
                    resultRange = import_vscode_languageserver_types11.Range.create(diag.range.start, import_vscode_languageserver_types11.Position.create(diag.range.end.line, diag.range.start.character + replacedTabs));
                }
                result.push(import_vscode_languageserver_types11.CodeAction.create("Convert Tab to Spaces", createWorkspaceEdit(document2.uri, [
                    import_vscode_languageserver_types11.TextEdit.replace(resultRange, newText)
                ]), import_vscode_languageserver_types11.CodeActionKind.QuickFix));
            }
        }
        if (result.length !== 0) {
            const replaceEdits = [];
            for(let i = 0; i <= textBuff.getLineCount(); i++){
                const lineContent = textBuff.getLineContent(i);
                let replacedTabs = 0;
                let newText = "";
                for(let j = 0; j < lineContent.length; j++){
                    const char = lineContent.charAt(j);
                    if (char !== " " && char !== "	") {
                        if (replacedTabs !== 0) {
                            replaceEdits.push(import_vscode_languageserver_types11.TextEdit.replace(import_vscode_languageserver_types11.Range.create(i, j - replacedTabs, i, j), newText));
                            replacedTabs = 0;
                            newText = "";
                        }
                        break;
                    }
                    if (char === " " && replacedTabs !== 0) {
                        replaceEdits.push(import_vscode_languageserver_types11.TextEdit.replace(import_vscode_languageserver_types11.Range.create(i, j - replacedTabs, i, j), newText));
                        replacedTabs = 0;
                        newText = "";
                        continue;
                    }
                    if (char === "	") {
                        newText += this.indentation;
                        replacedTabs++;
                    }
                }
                if (replacedTabs !== 0) {
                    replaceEdits.push(import_vscode_languageserver_types11.TextEdit.replace(import_vscode_languageserver_types11.Range.create(i, 0, i, textBuff.getLineLength(i)), newText));
                }
            }
            if (replaceEdits.length > 0) {
                result.push(import_vscode_languageserver_types11.CodeAction.create("Convert all Tabs to Spaces", createWorkspaceEdit(document2.uri, replaceEdits), import_vscode_languageserver_types11.CodeActionKind.QuickFix));
            }
        }
        return result;
    }
    getUnusedAnchorsDelete(diagnostics, document2) {
        const result = [];
        const buffer = new TextBuffer(document2);
        for (const diag of diagnostics){
            if (diag.message.startsWith("Unused anchor") && diag.source === YAML_SOURCE) {
                const range = import_vscode_languageserver_types11.Range.create(diag.range.start, diag.range.end);
                const actual = buffer.getText(range);
                const lineContent = buffer.getLineContent(range.end.line);
                const lastWhitespaceChar = getFirstNonWhitespaceCharacterAfterOffset(lineContent, range.end.character);
                range.end.character = lastWhitespaceChar;
                const action = import_vscode_languageserver_types11.CodeAction.create(`Delete unused anchor: ${actual}`, createWorkspaceEdit(document2.uri, [
                    import_vscode_languageserver_types11.TextEdit.del(range)
                ]), import_vscode_languageserver_types11.CodeActionKind.QuickFix);
                action.diagnostics = [
                    diag
                ];
                result.push(action);
            }
        }
        return result;
    }
    getConvertToBooleanActions(diagnostics, document2) {
        const results = [];
        for (const diagnostic of diagnostics){
            if (diagnostic.message === 'Incorrect type. Expected "boolean".') {
                const value1 = document2.getText(diagnostic.range).toLocaleLowerCase();
                if (value1 === '"true"' || value1 === '"false"' || value1 === "'true'" || value1 === "'false'") {
                    const newValue = value1.includes("true") ? "true" : "false";
                    results.push(import_vscode_languageserver_types11.CodeAction.create("Convert to boolean", createWorkspaceEdit(document2.uri, [
                        import_vscode_languageserver_types11.TextEdit.replace(diagnostic.range, newValue)
                    ]), import_vscode_languageserver_types11.CodeActionKind.QuickFix));
                }
            }
        }
        return results;
    }
    getConvertToBlockStyleActions(diagnostics, document2) {
        const results = [];
        for (const diagnostic of diagnostics){
            if (diagnostic.code === "flowMap" || diagnostic.code === "flowSeq") {
                const node = getNodeforDiagnostic(document2, diagnostic);
                if (isMap(node.internalNode) || isSeq(node.internalNode)) {
                    const blockTypeDescription = isMap(node.internalNode) ? "map" : "sequence";
                    const rewriter = new FlowStyleRewriter(this.indentation);
                    results.push(import_vscode_languageserver_types11.CodeAction.create(`Convert to block style ${blockTypeDescription}`, createWorkspaceEdit(document2.uri, [
                        import_vscode_languageserver_types11.TextEdit.replace(diagnostic.range, rewriter.write(node))
                    ]), import_vscode_languageserver_types11.CodeActionKind.QuickFix));
                }
            }
        }
        return results;
    }
    getKeyOrderActions(diagnostics, document2) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
        const results = [];
        for (const diagnostic of diagnostics){
            if ((diagnostic == null ? void 0 : diagnostic.code) === "mapKeyOrder") {
                let node = getNodeforDiagnostic(document2, diagnostic);
                while(node && node.type !== "object"){
                    node = node.parent;
                }
                if (node && isMap(node.internalNode)) {
                    const sorted = _.cloneDeep(node.internalNode);
                    if ((sorted.srcToken.type === "block-map" || sorted.srcToken.type === "flow-collection") && (node.internalNode.srcToken.type === "block-map" || node.internalNode.srcToken.type === "flow-collection")) {
                        sorted.srcToken.items.sort((a2, b)=>{
                            if (a2.key && b.key && cst_exports.isScalar(a2.key) && cst_exports.isScalar(b.key)) {
                                return a2.key.source.localeCompare(b.key.source);
                            }
                            if (!a2.key && b.key) {
                                return -1;
                            }
                            if (a2.key && !b.key) {
                                return 1;
                            }
                            if (!a2.key && !b.key) {
                                return 0;
                            }
                        });
                        for(let i = 0; i < sorted.srcToken.items.length; i++){
                            const item = sorted.srcToken.items[i];
                            const uItem = node.internalNode.srcToken.items[i];
                            item.start = uItem.start;
                            if (((_a = item.value) == null ? void 0 : _a.type) === "alias" || ((_b = item.value) == null ? void 0 : _b.type) === "scalar" || ((_c = item.value) == null ? void 0 : _c.type) === "single-quoted-scalar" || ((_d = item.value) == null ? void 0 : _d.type) === "double-quoted-scalar") {
                                const newLineIndex = (_g = (_f = (_e = item.value) == null ? void 0 : _e.end) == null ? void 0 : _f.findIndex((p)=>p.type === "newline")) != null ? _g : -1;
                                let newLineToken = null;
                                if (((_h = uItem.value) == null ? void 0 : _h.type) === "block-scalar") {
                                    newLineToken = (_j = (_i = uItem.value) == null ? void 0 : _i.props) == null ? void 0 : _j.find((p)=>p.type === "newline");
                                } else if (cst_exports.isScalar(uItem.value)) {
                                    newLineToken = (_l = (_k = uItem.value) == null ? void 0 : _k.end) == null ? void 0 : _l.find((p)=>p.type === "newline");
                                }
                                if (newLineToken && newLineIndex < 0) {
                                    item.value.end = (_m = item.value.end) != null ? _m : [];
                                    item.value.end.push(newLineToken);
                                }
                                if (!newLineToken && newLineIndex > -1) {
                                    item.value.end.splice(newLineIndex, 1);
                                }
                            } else if (((_n = item.value) == null ? void 0 : _n.type) === "block-scalar") {
                                const nwline = item.value.props.find((p)=>p.type === "newline");
                                if (!nwline) {
                                    item.value.props.push({
                                        type: "newline",
                                        indent: 0,
                                        offset: item.value.offset,
                                        source: "\n"
                                    });
                                }
                            }
                        }
                    }
                    const replaceRange = import_vscode_languageserver_types11.Range.create(document2.positionAt(node.offset), document2.positionAt(node.offset + node.length));
                    results.push(import_vscode_languageserver_types11.CodeAction.create("Fix key order for this map", createWorkspaceEdit(document2.uri, [
                        import_vscode_languageserver_types11.TextEdit.replace(replaceRange, cst_exports.stringify(sorted.srcToken))
                    ]), import_vscode_languageserver_types11.CodeActionKind.QuickFix));
                }
            }
        }
        return results;
    }
    constructor(clientCapabilities){
        this.clientCapabilities = clientCapabilities;
        this.indentation = "  ";
    }
};
function getNodeforDiagnostic(document2, diagnostic) {
    const yamlDocuments = yamlDocumentsCache.getYamlDocument(document2);
    const startOffset = document2.offsetAt(diagnostic.range.start);
    const yamlDoc = matchOffsetToDocument(startOffset, yamlDocuments);
    const node = yamlDoc.getNodeFromOffset(startOffset);
    return node;
}
function createWorkspaceEdit(uri, edits) {
    const changes = {};
    changes[uri] = edits;
    const edit = {
        changes
    };
    return edit;
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlOnTypeFormatting.js
var import_vscode_languageserver_types12 = __toESM(require_main());
function doDocumentOnTypeFormatting(document2, params) {
    const { position } = params;
    const tb = new TextBuffer(document2);
    if (params.ch === "\n") {
        const previousLine = tb.getLineContent(position.line - 1);
        if (previousLine.trimRight().endsWith(":")) {
            const currentLine = tb.getLineContent(position.line);
            const subLine = currentLine.substring(position.character, currentLine.length);
            const isInArray = previousLine.indexOf(" - ") !== -1;
            if (subLine.trimRight().length === 0) {
                const indentationFix = position.character - (previousLine.length - previousLine.trimLeft().length);
                if (indentationFix === params.options.tabSize && !isInArray) {
                    return;
                }
                const result = [];
                if (currentLine.length > 0) {
                    result.push(import_vscode_languageserver_types12.TextEdit.del(import_vscode_languageserver_types12.Range.create(position, import_vscode_languageserver_types12.Position.create(position.line, currentLine.length - 1))));
                }
                result.push(import_vscode_languageserver_types12.TextEdit.insert(position, " ".repeat(params.options.tabSize + (isInArray ? 2 - indentationFix : 0))));
                return result;
            }
            if (isInArray) {
                return [
                    import_vscode_languageserver_types12.TextEdit.insert(position, " ".repeat(params.options.tabSize))
                ];
            }
        }
        if (previousLine.trimRight().endsWith("|")) {
            return [
                import_vscode_languageserver_types12.TextEdit.insert(position, " ".repeat(params.options.tabSize))
            ];
        }
        if (previousLine.includes(" - ") && !previousLine.includes(": ")) {
            return [
                import_vscode_languageserver_types12.TextEdit.insert(position, "- ")
            ];
        }
        if (previousLine.includes(" - ") && previousLine.includes(": ")) {
            return [
                import_vscode_languageserver_types12.TextEdit.insert(position, "  ")
            ];
        }
    }
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlCodeLens.js
var import_vscode_languageserver_types13 = __toESM(require_main());
// ../../node_modules/yaml-language-server/lib/esm/languageservice/utils/schemaUrls.js
var JSON_SCHEMASTORE_URL = "https://www.schemastore.org/api/json/catalog.json";
function getSchemaUrls(schema4) {
    const result = /* @__PURE__ */ new Map();
    if (!schema4) {
        return result;
    }
    if (schema4.url) {
        if (schema4.url.startsWith("schemaservice://combinedSchema/")) {
            addSchemasForOf(schema4, result);
        } else {
            result.set(schema4.url, schema4);
        }
    } else {
        addSchemasForOf(schema4, result);
    }
    return result;
}
function addSchemasForOf(schema4, result) {
    if (schema4.allOf) {
        addInnerSchemaUrls(schema4.allOf, result);
    }
    if (schema4.anyOf) {
        addInnerSchemaUrls(schema4.anyOf, result);
    }
    if (schema4.oneOf) {
        addInnerSchemaUrls(schema4.oneOf, result);
    }
}
function addInnerSchemaUrls(schemas2, result) {
    for (const subSchema of schemas2){
        if (!isBoolean2(subSchema) && subSchema.url && !result.has(subSchema.url)) {
            result.set(subSchema.url, subSchema);
        }
    }
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlCodeLens.js
var YamlCodeLens = class {
    async getCodeLens(document2) {
        var _a;
        const result = [];
        try {
            const yamlDocument = yamlDocumentsCache.getYamlDocument(document2);
            let schemaUrls = /* @__PURE__ */ new Map();
            for (const currentYAMLDoc of yamlDocument.documents){
                const schema4 = await this.schemaService.getSchemaForResource(document2.uri, currentYAMLDoc);
                if (schema4 == null ? void 0 : schema4.schema) {
                    schemaUrls = new Map([
                        ...getSchemaUrls(schema4 == null ? void 0 : schema4.schema),
                        ...schemaUrls
                    ]);
                }
            }
            for (const urlToSchema of schemaUrls){
                const lens = import_vscode_languageserver_types13.CodeLens.create(import_vscode_languageserver_types13.Range.create(0, 0, 0, 0));
                lens.command = {
                    title: getSchemaTitle(urlToSchema[1], urlToSchema[0]),
                    command: YamlCommands.JUMP_TO_SCHEMA,
                    arguments: [
                        urlToSchema[0]
                    ]
                };
                result.push(lens);
            }
        } catch (err) {
            (_a = this.telemetry) == null ? void 0 : _a.sendError("yaml.codeLens.error", {
                error: convertErrorToTelemetryMsg(err)
            });
        }
        return result;
    }
    resolveCodeLens(param) {
        return param;
    }
    constructor(schemaService, telemetry){
        this.schemaService = schemaService;
        this.telemetry = telemetry;
    }
};
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlCompletion.js
var import_vscode_languageserver_types14 = __toESM(require_main());
// ../../node_modules/yaml-language-server/lib/esm/languageservice/utils/indentationGuesser.js
var SpacesDiffResult = class {
    constructor(){
        this.spacesDiff = 0;
        this.looksLikeAlignment = false;
    }
};
function spacesDiff(a2, aLength, b, bLength, result) {
    result.spacesDiff = 0;
    result.looksLikeAlignment = false;
    let i;
    for(i = 0; i < aLength && i < bLength; i++){
        const aCharCode = a2.charCodeAt(i);
        const bCharCode = b.charCodeAt(i);
        if (aCharCode !== bCharCode) {
            break;
        }
    }
    let aSpacesCnt = 0, aTabsCount = 0;
    for(let j = i; j < aLength; j++){
        const aCharCode = a2.charCodeAt(j);
        if (aCharCode === 32) {
            aSpacesCnt++;
        } else {
            aTabsCount++;
        }
    }
    let bSpacesCnt = 0, bTabsCount = 0;
    for(let j = i; j < bLength; j++){
        const bCharCode = b.charCodeAt(j);
        if (bCharCode === 32) {
            bSpacesCnt++;
        } else {
            bTabsCount++;
        }
    }
    if (aSpacesCnt > 0 && aTabsCount > 0) {
        return;
    }
    if (bSpacesCnt > 0 && bTabsCount > 0) {
        return;
    }
    const tabsDiff = Math.abs(aTabsCount - bTabsCount);
    const spacesDiff2 = Math.abs(aSpacesCnt - bSpacesCnt);
    if (tabsDiff === 0) {
        result.spacesDiff = spacesDiff2;
        if (spacesDiff2 > 0 && 0 <= bSpacesCnt - 1 && bSpacesCnt - 1 < a2.length && bSpacesCnt < b.length) {
            if (b.charCodeAt(bSpacesCnt) !== 32 && a2.charCodeAt(bSpacesCnt - 1) === 32) {
                if (a2.charCodeAt(a2.length - 1) === 44) {
                    result.looksLikeAlignment = true;
                }
            }
        }
        return;
    }
    if (spacesDiff2 % tabsDiff === 0) {
        result.spacesDiff = spacesDiff2 / tabsDiff;
    }
}
function guessIndentation(source, defaultTabSize, defaultInsertSpaces) {
    const linesCount = Math.min(source.getLineCount(), 1e4);
    let linesIndentedWithTabsCount = 0;
    let linesIndentedWithSpacesCount = 0;
    let previousLineText = "";
    let previousLineIndentation = 0;
    const ALLOWED_TAB_SIZE_GUESSES = [
        2,
        4,
        6,
        8,
        3,
        5,
        7
    ];
    const MAX_ALLOWED_TAB_SIZE_GUESS = 8;
    const spacesDiffCount = [
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0
    ];
    const tmp = new SpacesDiffResult();
    for(let lineNumber = 1; lineNumber <= linesCount; lineNumber++){
        const currentLineLength = source.getLineLength(lineNumber);
        const currentLineText = source.getLineContent(lineNumber);
        const useCurrentLineText = currentLineLength <= 65536;
        let currentLineHasContent = false;
        let currentLineIndentation = 0;
        let currentLineSpacesCount = 0;
        let currentLineTabsCount = 0;
        for(let j = 0, lenJ = currentLineLength; j < lenJ; j++){
            const charCode = useCurrentLineText ? currentLineText.charCodeAt(j) : source.getLineCharCode(lineNumber, j);
            if (charCode === 9) {
                currentLineTabsCount++;
            } else if (charCode === 32) {
                currentLineSpacesCount++;
            } else {
                currentLineHasContent = true;
                currentLineIndentation = j;
                break;
            }
        }
        if (!currentLineHasContent) {
            continue;
        }
        if (currentLineTabsCount > 0) {
            linesIndentedWithTabsCount++;
        } else if (currentLineSpacesCount > 1) {
            linesIndentedWithSpacesCount++;
        }
        spacesDiff(previousLineText, previousLineIndentation, currentLineText, currentLineIndentation, tmp);
        if (tmp.looksLikeAlignment) {
            if (!(defaultInsertSpaces && defaultTabSize === tmp.spacesDiff)) {
                continue;
            }
        }
        const currentSpacesDiff = tmp.spacesDiff;
        if (currentSpacesDiff <= MAX_ALLOWED_TAB_SIZE_GUESS) {
            spacesDiffCount[currentSpacesDiff]++;
        }
        previousLineText = currentLineText;
        previousLineIndentation = currentLineIndentation;
    }
    let insertSpaces = defaultInsertSpaces;
    if (linesIndentedWithTabsCount !== linesIndentedWithSpacesCount) {
        insertSpaces = linesIndentedWithTabsCount < linesIndentedWithSpacesCount;
    }
    let tabSize = defaultTabSize;
    if (insertSpaces) {
        let tabSizeScore = insertSpaces ? 0 : 0.1 * linesCount;
        ALLOWED_TAB_SIZE_GUESSES.forEach((possibleTabSize)=>{
            const possibleTabSizeScore = spacesDiffCount[possibleTabSize];
            if (possibleTabSizeScore > tabSizeScore) {
                tabSizeScore = possibleTabSizeScore;
                tabSize = possibleTabSize;
            }
        });
        if (tabSize === 4 && spacesDiffCount[4] > 0 && spacesDiffCount[2] > 0 && spacesDiffCount[2] >= spacesDiffCount[4] / 2) {
            tabSize = 2;
        }
    }
    return {
        insertSpaces,
        tabSize
    };
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/utils/json.js
function stringifyObject2(obj, indent, stringifyLiteral, settings, depth = 0, consecutiveArrays = 0) {
    if (obj !== null && typeof obj === "object") {
        const newIndent = depth === 0 && settings.shouldIndentWithTab || depth > 0 ? indent + settings.indentation : "";
        if (Array.isArray(obj)) {
            consecutiveArrays += 1;
            if (obj.length === 0) {
                return "";
            }
            let result = "";
            for(let i = 0; i < obj.length; i++){
                let pseudoObj = obj[i];
                if (typeof obj[i] !== "object") {
                    result += "\n" + newIndent + "- " + stringifyLiteral(obj[i]);
                    continue;
                }
                if (!Array.isArray(obj[i])) {
                    pseudoObj = prependToObject(obj[i], consecutiveArrays);
                }
                result += stringifyObject2(pseudoObj, indent, stringifyLiteral, settings, depth += 1, consecutiveArrays);
            }
            return result;
        } else {
            const keys = Object.keys(obj);
            if (keys.length === 0) {
                return "";
            }
            let result = depth === 0 && settings.newLineFirst || depth > 0 ? "\n" : "";
            let isFirstProp = true;
            for(let i = 0; i < keys.length; i++){
                const key = keys[i];
                if (depth === 0 && settings.existingProps.includes(key)) {
                    continue;
                }
                const isObject = typeof obj[key] === "object";
                const colonDelimiter = isObject ? ":" : ": ";
                const parentArrayCompensation = isObject && /^\s|-/.test(key) ? settings.indentation : "";
                const objectIndent = newIndent + parentArrayCompensation;
                const lineBreak = isFirstProp ? "" : "\n";
                if (depth === 0 && isFirstProp && !settings.indentFirstObject) {
                    const value1 = stringifyObject2(obj[key], objectIndent, stringifyLiteral, settings, depth + 1, 0);
                    result += lineBreak + indent + key + colonDelimiter + value1;
                } else {
                    const value1 = stringifyObject2(obj[key], objectIndent, stringifyLiteral, settings, depth + 1, 0);
                    result += lineBreak + newIndent + key + colonDelimiter + value1;
                }
                isFirstProp = false;
            }
            return result;
        }
    }
    return stringifyLiteral(obj);
}
function prependToObject(obj, consecutiveArrays) {
    const newObj = {};
    for(let i = 0; i < Object.keys(obj).length; i++){
        const key = Object.keys(obj)[i];
        if (i === 0) {
            newObj["- ".repeat(consecutiveArrays) + key] = obj[key];
        } else {
            newObj["  ".repeat(consecutiveArrays) + key] = obj[key];
        }
    }
    return newObj;
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlCompletion.js
var localize9 = loadMessageBundle();
var doubleQuotesEscapeRegExp = /[\\]+"/g;
var parentCompletionKind = import_vscode_languageserver_types14.CompletionItemKind.Class;
var existingProposeItem = "__";
var YamlCompletion = class {
    configure(languageSettings) {
        if (languageSettings) {
            this.completionEnabled = languageSettings.completion;
        }
        this.customTags = languageSettings.customTags;
        this.yamlVersion = languageSettings.yamlVersion;
        this.configuredIndentation = languageSettings.indentation;
        this.disableDefaultProperties = languageSettings.disableDefaultProperties;
        this.parentSkeletonSelectedFirst = languageSettings.parentSkeletonSelectedFirst;
    }
    async doComplete(document2, position, isKubernetes = false, doComplete = true) {
        var _a;
        const result = import_vscode_languageserver_types14.CompletionList.create([], false);
        if (!this.completionEnabled) {
            return result;
        }
        const doc = this.yamlDocument.getYamlDocument(document2, {
            customTags: this.customTags,
            yamlVersion: this.yamlVersion
        }, true);
        const textBuffer = new TextBuffer(document2);
        if (!this.configuredIndentation) {
            const indent = guessIndentation(textBuffer, 2, true);
            this.indentation = indent.insertSpaces ? " ".repeat(indent.tabSize) : "	";
        } else {
            this.indentation = this.configuredIndentation;
        }
        setKubernetesParserOption(doc.documents, isKubernetes);
        for (const jsonDoc of doc.documents){
            jsonDoc.uri = document2.uri;
        }
        const offset = document2.offsetAt(position);
        const text = document2.getText();
        if (text.charAt(offset - 1) === ":") {
            return Promise.resolve(result);
        }
        let currentDoc = matchOffsetToDocument(offset, doc);
        if (currentDoc === null) {
            return Promise.resolve(result);
        }
        currentDoc = currentDoc.clone();
        let [node, foundByClosest] = currentDoc.getNodeFromPosition(offset, textBuffer, this.indentation.length);
        const currentWord = this.getCurrentWord(document2, offset);
        let lineContent = textBuffer.getLineContent(position.line);
        const lineAfterPosition = lineContent.substring(position.character);
        const areOnlySpacesAfterPosition = /^[ ]+\n?$/.test(lineAfterPosition);
        this.arrayPrefixIndentation = "";
        let overwriteRange = null;
        if (areOnlySpacesAfterPosition) {
            overwriteRange = import_vscode_languageserver_types14.Range.create(position, import_vscode_languageserver_types14.Position.create(position.line, lineContent.length));
            const isOnlyWhitespace = lineContent.trim().length === 0;
            const isOnlyDash = lineContent.match(/^\s*(-)\s*$/);
            if (node && isScalar(node) && !isOnlyWhitespace && !isOnlyDash) {
                const lineToPosition = lineContent.substring(0, position.character);
                const matches = // get indentation of unfinished property (between indent and cursor)
                lineToPosition.match(/^[\s-]*([^:]+)?$/) || // OR get unfinished value (between colon and cursor)
                lineToPosition.match(/:[ \t]((?!:[ \t]).*)$/);
                if (matches == null ? void 0 : matches[1]) {
                    overwriteRange = import_vscode_languageserver_types14.Range.create(import_vscode_languageserver_types14.Position.create(position.line, position.character - matches[1].length), import_vscode_languageserver_types14.Position.create(position.line, lineContent.length));
                }
            }
        } else if (node && isScalar(node) && node.value === "null") {
            const nodeStartPos = document2.positionAt(node.range[0]);
            nodeStartPos.character += 1;
            const nodeEndPos = document2.positionAt(node.range[2]);
            nodeEndPos.character += 1;
            overwriteRange = import_vscode_languageserver_types14.Range.create(nodeStartPos, nodeEndPos);
        } else if (node && isScalar(node) && node.value) {
            const start = document2.positionAt(node.range[0]);
            overwriteRange = import_vscode_languageserver_types14.Range.create(start, document2.positionAt(node.range[1]));
        } else if (node && isScalar(node) && node.value === null && currentWord === "-") {
            overwriteRange = import_vscode_languageserver_types14.Range.create(position, position);
            this.arrayPrefixIndentation = " ";
        } else {
            let overwriteStart = offset - currentWord.length;
            if (overwriteStart > 0 && text[overwriteStart - 1] === '"') {
                overwriteStart--;
            }
            overwriteRange = import_vscode_languageserver_types14.Range.create(document2.positionAt(overwriteStart), position);
        }
        const proposed = {};
        const collector = {
            add: (completionItem, oneOfSchema)=>{
                const addSuggestionForParent = function(completionItem2) {
                    var _a2;
                    const existsInYaml = ((_a2 = proposed[completionItem2.label]) == null ? void 0 : _a2.label) === existingProposeItem;
                    if (existsInYaml) {
                        return;
                    }
                    const schema4 = completionItem2.parent.schema;
                    const schemaType = getSchemaTypeName(schema4);
                    const schemaDescription = schema4.markdownDescription || schema4.description;
                    let parentCompletion = result.items.find((item)=>{
                        var _a3;
                        return ((_a3 = item.parent) == null ? void 0 : _a3.schema) === schema4 && item.kind === parentCompletionKind;
                    });
                    if (parentCompletion && parentCompletion.parent.insertTexts.includes(completionItem2.insertText)) {
                        return;
                    } else if (!parentCompletion) {
                        parentCompletion = {
                            ...completionItem2,
                            label: schemaType,
                            documentation: schemaDescription,
                            sortText: "_" + schemaType,
                            kind: parentCompletionKind
                        };
                        parentCompletion.label = parentCompletion.label || completionItem2.label;
                        parentCompletion.parent.insertTexts = [
                            completionItem2.insertText
                        ];
                        result.items.push(parentCompletion);
                    } else {
                        parentCompletion.parent.insertTexts.push(completionItem2.insertText);
                    }
                };
                const isForParentCompletion = !!completionItem.parent;
                let label = completionItem.label;
                if (!label) {
                    console.warn(`Ignoring CompletionItem without label: ${JSON.stringify(completionItem)}`);
                    return;
                }
                if (!isString2(label)) {
                    label = String(label);
                }
                label = label.replace(/[\n]/g, "\u21B5");
                if (label.length > 60) {
                    const shortendedLabel = label.substr(0, 57).trim() + "...";
                    if (!proposed[shortendedLabel]) {
                        label = shortendedLabel;
                    }
                }
                if (completionItem.insertText.endsWith("$1") && !isForParentCompletion) {
                    completionItem.insertText = completionItem.insertText.substr(0, completionItem.insertText.length - 2);
                }
                if (overwriteRange && overwriteRange.start.line === overwriteRange.end.line) {
                    completionItem.textEdit = import_vscode_languageserver_types14.TextEdit.replace(overwriteRange, completionItem.insertText);
                }
                completionItem.label = label;
                if (isForParentCompletion) {
                    addSuggestionForParent(completionItem);
                    return;
                }
                if (this.arrayPrefixIndentation) {
                    this.updateCompletionText(completionItem, this.arrayPrefixIndentation + completionItem.insertText);
                }
                const existing = proposed[label];
                const isInsertTextDifferent = (existing == null ? void 0 : existing.label) !== existingProposeItem && (existing == null ? void 0 : existing.insertText) !== completionItem.insertText;
                if (!existing) {
                    proposed[label] = completionItem;
                    result.items.push(completionItem);
                } else if (isInsertTextDifferent) {
                    const mergedText = this.mergeSimpleInsertTexts(label, existing.insertText, completionItem.insertText, oneOfSchema);
                    if (mergedText) {
                        this.updateCompletionText(existing, mergedText);
                    } else {
                        proposed[label] = completionItem;
                        result.items.push(completionItem);
                    }
                }
                if (existing && !existing.documentation && completionItem.documentation) {
                    existing.documentation = completionItem.documentation;
                }
            },
            error: (message)=>{
                var _a2;
                (_a2 = this.telemetry) == null ? void 0 : _a2.sendError("yaml.completion.error", {
                    error: convertErrorToTelemetryMsg(message)
                });
            },
            log: (message)=>{
                console.log(message);
            },
            getNumberOfProposals: ()=>{
                return result.items.length;
            },
            result,
            proposed
        };
        if (this.customTags.length > 0) {
            this.getCustomTagValueCompletions(collector);
        }
        if (lineContent.endsWith("\n")) {
            lineContent = lineContent.substr(0, lineContent.length - 1);
        }
        try {
            const schema4 = await this.schemaService.getSchemaForResource(document2.uri, currentDoc);
            if (!schema4 || schema4.errors.length) {
                if (position.line === 0 && position.character === 0 && !isModeline(lineContent)) {
                    const inlineSchemaCompletion = {
                        kind: import_vscode_languageserver_types14.CompletionItemKind.Text,
                        label: "Inline schema",
                        insertText: "# yaml-language-server: $schema=",
                        insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.PlainText
                    };
                    result.items.push(inlineSchemaCompletion);
                }
            }
            if (isModeline(lineContent) || isInComment(doc.tokens, offset)) {
                const schemaIndex = lineContent.indexOf("$schema=");
                if (schemaIndex !== -1 && schemaIndex + "$schema=".length <= position.character) {
                    this.schemaService.getAllSchemas().forEach((schema5)=>{
                        var _a2;
                        const schemaIdCompletion = {
                            kind: import_vscode_languageserver_types14.CompletionItemKind.Constant,
                            label: (_a2 = schema5.name) != null ? _a2 : schema5.uri,
                            detail: schema5.description,
                            insertText: schema5.uri,
                            insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.PlainText,
                            insertTextMode: import_vscode_languageserver_types14.InsertTextMode.asIs
                        };
                        result.items.push(schemaIdCompletion);
                    });
                }
                return result;
            }
            if (!schema4 || schema4.errors.length) {
                return result;
            }
            let currentProperty = null;
            if (!node) {
                if (!currentDoc.internalDocument.contents || isScalar(currentDoc.internalDocument.contents)) {
                    const map2 = currentDoc.internalDocument.createNode({});
                    map2.range = [
                        offset,
                        offset + 1,
                        offset + 1
                    ];
                    currentDoc.internalDocument.contents = map2;
                    currentDoc.updateFromInternalDocument();
                    node = map2;
                } else {
                    node = currentDoc.findClosestNode(offset, textBuffer);
                    foundByClosest = true;
                }
            }
            const originalNode = node;
            if (node) {
                if (lineContent.length === 0) {
                    node = currentDoc.internalDocument.contents;
                } else {
                    const parent = currentDoc.getParent(node);
                    if (parent) {
                        if (isScalar(node)) {
                            if (node.value) {
                                if (isPair(parent)) {
                                    if (parent.value === node) {
                                        if (lineContent.trim().length > 0 && lineContent.indexOf(":") < 0) {
                                            const map2 = this.createTempObjNode(currentWord, node, currentDoc);
                                            const parentParent = currentDoc.getParent(parent);
                                            if (isSeq(currentDoc.internalDocument.contents)) {
                                                const index = indexOf(currentDoc.internalDocument.contents, parent);
                                                if (typeof index === "number") {
                                                    currentDoc.internalDocument.set(index, map2);
                                                    currentDoc.updateFromInternalDocument();
                                                }
                                            } else if (parentParent && (isMap(parentParent) || isSeq(parentParent))) {
                                                parentParent.set(parent.key, map2);
                                                currentDoc.updateFromInternalDocument();
                                            } else {
                                                currentDoc.internalDocument.set(parent.key, map2);
                                                currentDoc.updateFromInternalDocument();
                                            }
                                            currentProperty = map2.items[0];
                                            node = map2;
                                        } else if (lineContent.trim().length === 0) {
                                            const parentParent = currentDoc.getParent(parent);
                                            if (parentParent) {
                                                node = parentParent;
                                            }
                                        }
                                    } else if (parent.key === node) {
                                        const parentParent = currentDoc.getParent(parent);
                                        currentProperty = parent;
                                        if (parentParent) {
                                            node = parentParent;
                                        }
                                    }
                                } else if (isSeq(parent)) {
                                    if (lineContent.trim().length > 0) {
                                        const map2 = this.createTempObjNode(currentWord, node, currentDoc);
                                        parent.delete(node);
                                        parent.add(map2);
                                        currentDoc.updateFromInternalDocument();
                                        node = map2;
                                    } else {
                                        node = parent;
                                    }
                                }
                            } else if (node.value === null) {
                                if (isPair(parent)) {
                                    if (parent.key === node) {
                                        node = parent;
                                    } else {
                                        if (isNode(parent.key) && parent.key.range) {
                                            const parentParent = currentDoc.getParent(parent);
                                            if (foundByClosest && parentParent && isMap(parentParent) && isMapContainsEmptyPair(parentParent)) {
                                                node = parentParent;
                                            } else {
                                                const parentPosition = document2.positionAt(parent.key.range[0]);
                                                if (position.character > parentPosition.character && position.line !== parentPosition.line) {
                                                    const map2 = this.createTempObjNode(currentWord, node, currentDoc);
                                                    if (parentParent && (isMap(parentParent) || isSeq(parentParent))) {
                                                        parentParent.set(parent.key, map2);
                                                        currentDoc.updateFromInternalDocument();
                                                    } else {
                                                        currentDoc.internalDocument.set(parent.key, map2);
                                                        currentDoc.updateFromInternalDocument();
                                                    }
                                                    currentProperty = map2.items[0];
                                                    node = map2;
                                                } else if (parentPosition.character === position.character) {
                                                    if (parentParent) {
                                                        node = parentParent;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                } else if (isSeq(parent)) {
                                    if (lineContent.charAt(position.character - 1) !== "-") {
                                        const map2 = this.createTempObjNode(currentWord, node, currentDoc);
                                        parent.delete(node);
                                        parent.add(map2);
                                        currentDoc.updateFromInternalDocument();
                                        node = map2;
                                    } else if (lineContent.charAt(position.character - 1) === "-") {
                                        const map2 = this.createTempObjNode("", node, currentDoc);
                                        parent.delete(node);
                                        parent.add(map2);
                                        currentDoc.updateFromInternalDocument();
                                        node = map2;
                                    } else {
                                        node = parent;
                                    }
                                }
                            }
                        } else if (isMap(node)) {
                            if (!foundByClosest && lineContent.trim().length === 0 && isSeq(parent)) {
                                const nextLine = textBuffer.getLineContent(position.line + 1);
                                if (textBuffer.getLineCount() === position.line + 1 || nextLine.trim().length === 0) {
                                    node = parent;
                                }
                            }
                        }
                    } else if (isScalar(node)) {
                        const map2 = this.createTempObjNode(currentWord, node, currentDoc);
                        currentDoc.internalDocument.contents = map2;
                        currentDoc.updateFromInternalDocument();
                        currentProperty = map2.items[0];
                        node = map2;
                    } else if (isMap(node)) {
                        for (const pair of node.items){
                            if (isNode(pair.value) && pair.value.range && pair.value.range[0] === offset + 1) {
                                node = pair.value;
                            }
                        }
                    } else if (isSeq(node)) {
                        if (lineContent.charAt(position.character - 1) !== "-") {
                            const map2 = this.createTempObjNode(currentWord, node, currentDoc);
                            map2.items = [];
                            currentDoc.updateFromInternalDocument();
                            for (const pair of node.items){
                                if (isMap(pair)) {
                                    pair.items.forEach((value1)=>{
                                        map2.items.push(value1);
                                    });
                                }
                            }
                            node = map2;
                        }
                    }
                }
            }
            if (node && isMap(node)) {
                const properties = node.items;
                for (const p of properties){
                    if (!currentProperty || currentProperty !== p) {
                        if (isScalar(p.key)) {
                            proposed[p.key.value + ""] = import_vscode_languageserver_types14.CompletionItem.create(existingProposeItem);
                        }
                    }
                }
                this.addPropertyCompletions(schema4, currentDoc, node, originalNode, "", collector, textBuffer, overwriteRange, doComplete);
                if (!schema4 && currentWord.length > 0 && text.charAt(offset - currentWord.length - 1) !== '"') {
                    collector.add({
                        kind: import_vscode_languageserver_types14.CompletionItemKind.Property,
                        label: currentWord,
                        insertText: this.getInsertTextForProperty(currentWord, null, ""),
                        insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet
                    });
                }
            }
            const types = {};
            this.getValueCompletions(schema4, currentDoc, node, offset, document2, collector, types, doComplete);
        } catch (err) {
            (_a = this.telemetry) == null ? void 0 : _a.sendError("yaml.completion.error", {
                error: convertErrorToTelemetryMsg(err)
            });
        }
        this.finalizeParentCompletion(result);
        const uniqueItems = result.items.filter((arr, index, self2)=>index === self2.findIndex((item)=>item.label === arr.label && item.insertText === arr.insertText && item.kind === arr.kind));
        if ((uniqueItems == null ? void 0 : uniqueItems.length) > 0) {
            result.items = uniqueItems;
        }
        return result;
    }
    updateCompletionText(completionItem, text) {
        completionItem.insertText = text;
        if (completionItem.textEdit) {
            completionItem.textEdit.newText = text;
        }
    }
    mergeSimpleInsertTexts(label, existingText, addingText, oneOfSchema) {
        const containsNewLineAfterColon = (value1)=>{
            return value1.includes("\n");
        };
        const startWithNewLine = (value1)=>{
            return value1.startsWith("\n");
        };
        const isNullObject = (value1)=>{
            const index = value1.indexOf("\n");
            return index > 0 && value1.substring(index, value1.length).trim().length === 0;
        };
        if (containsNewLineAfterColon(existingText) || containsNewLineAfterColon(addingText)) {
            if (oneOfSchema && isNullObject(existingText) && !isNullObject(addingText) && !startWithNewLine(addingText)) {
                return addingText;
            }
            return void 0;
        }
        const existingValues = this.getValuesFromInsertText(existingText);
        const addingValues = this.getValuesFromInsertText(addingText);
        const newValues = Array.prototype.concat(existingValues, addingValues);
        if (!newValues.length) {
            return void 0;
        } else if (newValues.length === 1) {
            return `${label}: \${1:${newValues[0]}}`;
        } else {
            return `${label}: \${1|${newValues.join(",")}|}`;
        }
    }
    getValuesFromInsertText(insertText) {
        const value1 = insertText.substring(insertText.indexOf(":") + 1).trim();
        if (!value1) {
            return [];
        }
        const valueMath = value1.match(/^\${1[|:]([^|]*)+\|?}$/);
        if (valueMath) {
            return valueMath[1].split(",");
        }
        return [
            value1
        ];
    }
    finalizeParentCompletion(result) {
        const reindexText = (insertTexts)=>{
            let max$index = 0;
            return insertTexts.map((text)=>{
                const match = text.match(/\$([0-9]+)|\${[0-9]+:/g);
                if (!match) {
                    return text;
                }
                const max$indexLocal = match.map((m)=>+m.replace(/\${([0-9]+)[:|]/g, "$1").replace("$", "")).reduce((p, n)=>n > p ? n : p, 0);
                const reindexedStr = text.replace(/\$([0-9]+)/g, (s, args)=>"$" + (+args + max$index)).replace(/\${([0-9]+)[:|]/g, (s, args)=>"${" + (+args + max$index) + ":");
                max$index += max$indexLocal;
                return reindexedStr;
            });
        };
        result.items.forEach((completionItem)=>{
            if (isParentCompletionItem(completionItem)) {
                const indent = completionItem.parent.indent || "";
                const reindexedTexts = reindexText(completionItem.parent.insertTexts);
                let insertText = reindexedTexts.join(`
${indent}`);
                if (insertText.endsWith("$1")) {
                    insertText = insertText.substring(0, insertText.length - 2);
                }
                completionItem.insertText = this.arrayPrefixIndentation + insertText;
                if (completionItem.textEdit) {
                    completionItem.textEdit.newText = completionItem.insertText;
                }
                const mdText = insertText.replace(/\${[0-9]+[:|](.*)}/g, (s, arg)=>arg).replace(/\$([0-9]+)/g, "");
                const originalDocumentation = completionItem.documentation ? [
                    completionItem.documentation,
                    "",
                    "----",
                    ""
                ] : [];
                completionItem.documentation = {
                    kind: import_vscode_languageserver_types14.MarkupKind.Markdown,
                    value: [
                        ...originalDocumentation,
                        "```yaml",
                        indent + mdText,
                        "```"
                    ].join("\n")
                };
                delete completionItem.parent;
            }
        });
    }
    createTempObjNode(currentWord, node, currentDoc) {
        const obj = {};
        obj[currentWord] = null;
        const map2 = currentDoc.internalDocument.createNode(obj);
        map2.range = node.range;
        map2.items[0].key.range = node.range;
        map2.items[0].value.range = node.range;
        return map2;
    }
    addPropertyCompletions(schema4, doc, node, originalNode, separatorAfter, collector, textBuffer, overwriteRange, doComplete) {
        var _a, _b, _c;
        const matchingSchemas = doc.getMatchingSchemas(schema4.schema, -1, null, doComplete);
        const existingKey = textBuffer.getText(overwriteRange);
        const lineContent = textBuffer.getLineContent(overwriteRange.start.line);
        const hasOnlyWhitespace = lineContent.trim().length === 0;
        const hasColon = lineContent.indexOf(":") !== -1;
        const isInArray = lineContent.trimLeft().indexOf("-") === 0;
        const nodeParent = doc.getParent(node);
        const matchOriginal = matchingSchemas.find((it)=>it.node.internalNode === originalNode && it.schema.properties);
        const oneOfSchema = matchingSchemas.filter((schema5)=>schema5.schema.oneOf).map((oneOfSchema2)=>oneOfSchema2.schema.oneOf)[0];
        let didOneOfSchemaMatches = false;
        if ((oneOfSchema == null ? void 0 : oneOfSchema.length) < matchingSchemas.length) {
            oneOfSchema == null ? void 0 : oneOfSchema.forEach((property, index)=>{
                var _a2, _b2;
                if (!((_a2 = matchingSchemas[index]) == null ? void 0 : _a2.schema.oneOf) && ((_b2 = matchingSchemas[index]) == null ? void 0 : _b2.schema.properties) === property.properties) {
                    didOneOfSchemaMatches = true;
                }
            });
        }
        for (const schema5 of matchingSchemas){
            if ((schema5.node.internalNode === node && !matchOriginal || schema5.node.internalNode === originalNode && !hasColon || ((_a = schema5.node.parent) == null ? void 0 : _a.internalNode) === originalNode && !hasColon) && !schema5.inverted) {
                this.collectDefaultSnippets(schema5.schema, separatorAfter, collector, {
                    newLineFirst: false,
                    indentFirstObject: false,
                    shouldIndentWithTab: isInArray
                });
                const schemaProperties = schema5.schema.properties;
                if (schemaProperties) {
                    const maxProperties = schema5.schema.maxProperties;
                    if (maxProperties === void 0 || node.items === void 0 || node.items.length < maxProperties || node.items.length === maxProperties && !hasOnlyWhitespace) {
                        for(const key in schemaProperties){
                            if (Object.prototype.hasOwnProperty.call(schemaProperties, key)) {
                                const propertySchema = schemaProperties[key];
                                if (typeof propertySchema === "object" && !propertySchema.deprecationMessage && !propertySchema["doNotSuggest"]) {
                                    let identCompensation = "";
                                    if (nodeParent && isSeq(nodeParent) && node.items.length <= 1 && !hasOnlyWhitespace) {
                                        const sourceText = textBuffer.getText();
                                        const indexOfSlash = sourceText.lastIndexOf("-", node.range[0] - 1);
                                        if (indexOfSlash >= 0) {
                                            const overwriteChars = overwriteRange.end.character - overwriteRange.start.character;
                                            identCompensation = " " + sourceText.slice(indexOfSlash + 1, node.range[1] - overwriteChars);
                                        }
                                    }
                                    identCompensation += this.arrayPrefixIndentation;
                                    let pair;
                                    if (propertySchema.type === "array" && (pair = node.items.find((it)=>isScalar(it.key) && it.key.range && it.key.value === key && isScalar(it.value) && !it.value.value && textBuffer.getPosition(it.key.range[2]).line === overwriteRange.end.line - 1)) && pair) {
                                        if (Array.isArray(propertySchema.items)) {
                                            this.addSchemaValueCompletions(propertySchema.items[0], separatorAfter, collector, {}, "property");
                                        } else if (typeof propertySchema.items === "object" && propertySchema.items.type === "object") {
                                            this.addArrayItemValueCompletion(propertySchema.items, separatorAfter, collector);
                                        }
                                    }
                                    let insertText = key;
                                    if (!key.startsWith(existingKey) || !hasColon) {
                                        insertText = this.getInsertTextForProperty(key, propertySchema, separatorAfter, identCompensation + this.indentation);
                                    }
                                    const isNodeNull = isScalar(originalNode) && originalNode.value === null || isMap(originalNode) && originalNode.items.length === 0;
                                    const existsParentCompletion = ((_b = schema5.schema.required) == null ? void 0 : _b.length) > 0;
                                    if (!this.parentSkeletonSelectedFirst || !isNodeNull || !existsParentCompletion) {
                                        collector.add({
                                            kind: import_vscode_languageserver_types14.CompletionItemKind.Property,
                                            label: key,
                                            insertText,
                                            insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet,
                                            documentation: this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || ""
                                        }, didOneOfSchemaMatches);
                                    }
                                    if ((_c = schema5.schema.required) == null ? void 0 : _c.includes(key)) {
                                        collector.add({
                                            label: key,
                                            insertText: this.getInsertTextForProperty(key, propertySchema, separatorAfter, identCompensation + this.indentation),
                                            insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet,
                                            documentation: this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || "",
                                            parent: {
                                                schema: schema5.schema,
                                                indent: identCompensation
                                            }
                                        });
                                    }
                                }
                            }
                        }
                    }
                }
                if (nodeParent && isSeq(nodeParent) && isPrimitiveType(schema5.schema)) {
                    this.addSchemaValueCompletions(schema5.schema, separatorAfter, collector, {}, "property", Array.isArray(nodeParent.items));
                }
                if (schema5.schema.propertyNames && schema5.schema.additionalProperties && schema5.schema.type === "object") {
                    const propertyNameSchema = asSchema2(schema5.schema.propertyNames);
                    const label = propertyNameSchema.title || "property";
                    collector.add({
                        kind: import_vscode_languageserver_types14.CompletionItemKind.Property,
                        label,
                        insertText: `\${1:${label}}: `,
                        insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet,
                        documentation: this.fromMarkup(propertyNameSchema.markdownDescription) || propertyNameSchema.description || ""
                    });
                }
            }
            if (nodeParent && schema5.node.internalNode === nodeParent && schema5.schema.defaultSnippets) {
                if (node.items.length === 1) {
                    this.collectDefaultSnippets(schema5.schema, separatorAfter, collector, {
                        newLineFirst: false,
                        indentFirstObject: false,
                        shouldIndentWithTab: true
                    }, 1);
                } else {
                    this.collectDefaultSnippets(schema5.schema, separatorAfter, collector, {
                        newLineFirst: false,
                        indentFirstObject: true,
                        shouldIndentWithTab: false
                    }, 1);
                }
            }
        }
    }
    getValueCompletions(schema4, doc, node, offset, document2, collector, types, doComplete) {
        let parentKey = null;
        if (node && isScalar(node)) {
            node = doc.getParent(node);
        }
        if (!node) {
            this.addSchemaValueCompletions(schema4.schema, "", collector, types, "value");
            return;
        }
        if (isPair(node)) {
            const valueNode = node.value;
            if (valueNode && valueNode.range && offset > valueNode.range[0] + valueNode.range[2]) {
                return;
            }
            parentKey = isScalar(node.key) ? node.key.value + "" : null;
            node = doc.getParent(node);
        }
        if (node && (parentKey !== null || isSeq(node))) {
            const separatorAfter = "";
            const matchingSchemas = doc.getMatchingSchemas(schema4.schema, -1, null, doComplete);
            for (const s of matchingSchemas){
                if (s.node.internalNode === node && !s.inverted && s.schema) {
                    if (s.schema.items) {
                        this.collectDefaultSnippets(s.schema, separatorAfter, collector, {
                            newLineFirst: false,
                            indentFirstObject: false,
                            shouldIndentWithTab: false
                        });
                        if (isSeq(node) && node.items) {
                            if (Array.isArray(s.schema.items)) {
                                const index = this.findItemAtOffset(node, document2, offset);
                                if (index < s.schema.items.length) {
                                    this.addSchemaValueCompletions(s.schema.items[index], separatorAfter, collector, types, "value");
                                }
                            } else if (typeof s.schema.items === "object" && (s.schema.items.type === "object" || isAnyOfAllOfOneOfType(s.schema.items))) {
                                this.addSchemaValueCompletions(s.schema.items, separatorAfter, collector, types, "value", true);
                            } else {
                                this.addSchemaValueCompletions(s.schema.items, separatorAfter, collector, types, "value");
                            }
                        }
                    }
                    if (s.schema.properties) {
                        const propertySchema = s.schema.properties[parentKey];
                        if (propertySchema) {
                            this.addSchemaValueCompletions(propertySchema, separatorAfter, collector, types, "value");
                        }
                    } else if (s.schema.additionalProperties) {
                        this.addSchemaValueCompletions(s.schema.additionalProperties, separatorAfter, collector, types, "value");
                    }
                }
            }
            if (types["boolean"]) {
                this.addBooleanValueCompletion(true, separatorAfter, collector);
                this.addBooleanValueCompletion(false, separatorAfter, collector);
            }
            if (types["null"]) {
                this.addNullValueCompletion(separatorAfter, collector);
            }
        }
    }
    addArrayItemValueCompletion(schema4, separatorAfter, collector, index) {
        const schemaType = getSchemaTypeName(schema4);
        const insertText = `- ${this.getInsertTextForObject(schema4, separatorAfter).insertText.trimLeft()}`;
        const schemaTypeTitle = schemaType ? " type `" + schemaType + "`" : "";
        const schemaDescription = schema4.description ? " (" + schema4.description + ")" : "";
        const documentation = this.getDocumentationWithMarkdownText(`Create an item of an array${schemaTypeTitle}${schemaDescription}`, insertText);
        collector.add({
            kind: this.getSuggestionKind(schema4.type),
            label: "- (array item) " + (schemaType || index),
            documentation,
            insertText,
            insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet
        });
    }
    getInsertTextForProperty(key, propertySchema, separatorAfter, indent = this.indentation) {
        const propertyText = this.getInsertTextForValue(key, "", "string");
        const resultText = propertyText + ":";
        let value1;
        let nValueProposals = 0;
        if (propertySchema) {
            let type = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;
            if (!type) {
                if (propertySchema.properties) {
                    type = "object";
                } else if (propertySchema.items) {
                    type = "array";
                } else if (propertySchema.anyOf) {
                    type = "anyOf";
                }
            }
            if (Array.isArray(propertySchema.defaultSnippets)) {
                if (propertySchema.defaultSnippets.length === 1) {
                    const body = propertySchema.defaultSnippets[0].body;
                    if (isDefined2(body)) {
                        value1 = this.getInsertTextForSnippetValue(body, "", {
                            newLineFirst: true,
                            indentFirstObject: false,
                            shouldIndentWithTab: false
                        }, [], 1);
                        if (!value1.startsWith(" ") && !value1.startsWith("\n")) {
                            value1 = " " + value1;
                        }
                    }
                }
                nValueProposals += propertySchema.defaultSnippets.length;
            }
            if (propertySchema.enum) {
                if (!value1 && propertySchema.enum.length === 1) {
                    value1 = " " + this.getInsertTextForGuessedValue(propertySchema.enum[0], "", type);
                }
                nValueProposals += propertySchema.enum.length;
            }
            if (propertySchema.const) {
                if (!value1) {
                    value1 = this.getInsertTextForGuessedValue(propertySchema.const, "", type);
                    value1 = evaluateTab1Symbol(value1);
                    value1 = " " + value1;
                }
                nValueProposals++;
            }
            if (isDefined2(propertySchema.default)) {
                if (!value1) {
                    value1 = " " + this.getInsertTextForGuessedValue(propertySchema.default, "", type);
                }
                nValueProposals++;
            }
            if (Array.isArray(propertySchema.examples) && propertySchema.examples.length) {
                if (!value1) {
                    value1 = " " + this.getInsertTextForGuessedValue(propertySchema.examples[0], "", type);
                }
                nValueProposals += propertySchema.examples.length;
            }
            if (propertySchema.properties) {
                return `${resultText}
${this.getInsertTextForObject(propertySchema, separatorAfter, indent).insertText}`;
            } else if (propertySchema.items) {
                return `${resultText}
${indent}- ${this.getInsertTextForArray(propertySchema.items, separatorAfter, 1, indent).insertText}`;
            }
            if (nValueProposals === 0) {
                switch(type){
                    case "boolean":
                        value1 = " $1";
                        break;
                    case "string":
                        value1 = " $1";
                        break;
                    case "object":
                        value1 = `
${indent}`;
                        break;
                    case "array":
                        value1 = `
${indent}- `;
                        break;
                    case "number":
                    case "integer":
                        value1 = " ${1:0}";
                        break;
                    case "null":
                        value1 = " ${1:null}";
                        break;
                    case "anyOf":
                        value1 = " $1";
                        break;
                    default:
                        return propertyText;
                }
            }
        }
        if (!value1 || nValueProposals > 1) {
            value1 = " $1";
        }
        return resultText + value1 + separatorAfter;
    }
    getInsertTextForObject(schema4, separatorAfter, indent = this.indentation, insertIndex = 1) {
        let insertText = "";
        if (!schema4.properties) {
            insertText = `${indent}$${insertIndex++}
`;
            return {
                insertText,
                insertIndex
            };
        }
        Object.keys(schema4.properties).forEach((key)=>{
            const propertySchema = schema4.properties[key];
            let type = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;
            if (!type) {
                if (propertySchema.anyOf) {
                    type = "anyOf";
                }
                if (propertySchema.properties) {
                    type = "object";
                }
                if (propertySchema.items) {
                    type = "array";
                }
            }
            if (schema4.required && schema4.required.indexOf(key) > -1) {
                switch(type){
                    case "boolean":
                    case "string":
                    case "number":
                    case "integer":
                    case "anyOf":
                        {
                            let value1 = propertySchema.default || propertySchema.const;
                            if (value1) {
                                if (type === "string") {
                                    value1 = convertToStringValue(value1);
                                }
                                insertText += `${indent}${key}: \${${insertIndex++}:${value1}}
`;
                            } else {
                                insertText += `${indent}${key}: $${insertIndex++}
`;
                            }
                            break;
                        }
                    case "array":
                        {
                            const arrayInsertResult = this.getInsertTextForArray(propertySchema.items, separatorAfter, insertIndex++, indent);
                            const arrayInsertLines = arrayInsertResult.insertText.split("\n");
                            let arrayTemplate = arrayInsertResult.insertText;
                            if (arrayInsertLines.length > 1) {
                                for(let index = 1; index < arrayInsertLines.length; index++){
                                    const element = arrayInsertLines[index];
                                    arrayInsertLines[index] = `  ${element}`;
                                }
                                arrayTemplate = arrayInsertLines.join("\n");
                            }
                            insertIndex = arrayInsertResult.insertIndex;
                            insertText += `${indent}${key}:
${indent}${this.indentation}- ${arrayTemplate}
`;
                        }
                        break;
                    case "object":
                        {
                            const objectInsertResult = this.getInsertTextForObject(propertySchema, separatorAfter, `${indent}${this.indentation}`, insertIndex++);
                            insertIndex = objectInsertResult.insertIndex;
                            insertText += `${indent}${key}:
${objectInsertResult.insertText}
`;
                        }
                        break;
                }
            } else if (!this.disableDefaultProperties && propertySchema.default !== void 0) {
                switch(type){
                    case "boolean":
                    case "number":
                    case "integer":
                        insertText += `${indent}${key === "null" ? this.getInsertTextForValue(key, "", "string") : key}: \${${insertIndex++}:${propertySchema.default}}
`;
                        break;
                    case "string":
                        insertText += `${indent}${key}: \${${insertIndex++}:${convertToStringValue(propertySchema.default)}}
`;
                        break;
                    case "array":
                    case "object":
                        break;
                }
            }
        });
        if (insertText.trim().length === 0) {
            insertText = `${indent}$${insertIndex++}
`;
        }
        insertText = insertText.trimRight() + separatorAfter;
        return {
            insertText,
            insertIndex
        };
    }
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    getInsertTextForArray(schema4, separatorAfter, insertIndex = 1, indent = this.indentation) {
        let insertText = "";
        if (!schema4) {
            insertText = `$${insertIndex++}`;
            return {
                insertText,
                insertIndex
            };
        }
        let type = Array.isArray(schema4.type) ? schema4.type[0] : schema4.type;
        if (!type) {
            if (schema4.properties) {
                type = "object";
            }
            if (schema4.items) {
                type = "array";
            }
        }
        switch(schema4.type){
            case "boolean":
                insertText = `\${${insertIndex++}:false}`;
                break;
            case "number":
            case "integer":
                insertText = `\${${insertIndex++}:0}`;
                break;
            case "string":
                insertText = `\${${insertIndex++}:""}`;
                break;
            case "object":
                {
                    const objectInsertResult = this.getInsertTextForObject(schema4, separatorAfter, `${indent}  `, insertIndex++);
                    insertText = objectInsertResult.insertText.trimLeft();
                    insertIndex = objectInsertResult.insertIndex;
                }
                break;
        }
        return {
            insertText,
            insertIndex
        };
    }
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    getInsertTextForGuessedValue(value1, separatorAfter, type) {
        switch(typeof value1){
            case "object":
                if (value1 === null) {
                    return "${1:null}" + separatorAfter;
                }
                return this.getInsertTextForValue(value1, separatorAfter, type);
            case "string":
                {
                    let snippetValue = JSON.stringify(value1);
                    snippetValue = snippetValue.substr(1, snippetValue.length - 2);
                    snippetValue = this.getInsertTextForPlainText(snippetValue);
                    if (type === "string") {
                        snippetValue = convertToStringValue(snippetValue);
                    }
                    return "${1:" + snippetValue + "}" + separatorAfter;
                }
            case "number":
            case "boolean":
                return "${1:" + value1 + "}" + separatorAfter;
        }
        return this.getInsertTextForValue(value1, separatorAfter, type);
    }
    getInsertTextForPlainText(text) {
        return text.replace(/[\\$}]/g, "\\$&");
    }
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    getInsertTextForValue(value1, separatorAfter, type) {
        if (value1 === null) {
            return "null";
        }
        switch(typeof value1){
            case "object":
                {
                    const indent = this.indentation;
                    return this.getInsertTemplateForValue(value1, indent, {
                        index: 1
                    }, separatorAfter);
                }
            case "number":
            case "boolean":
                return this.getInsertTextForPlainText(value1 + separatorAfter);
        }
        type = Array.isArray(type) ? type[0] : type;
        if (type === "string") {
            value1 = convertToStringValue(value1);
        }
        return this.getInsertTextForPlainText(value1 + separatorAfter);
    }
    getInsertTemplateForValue(value1, indent, navOrder, separatorAfter) {
        if (Array.isArray(value1)) {
            let insertText = "\n";
            for (const arrValue of value1){
                insertText += `${indent}- \${${navOrder.index++}:${arrValue}}
`;
            }
            return insertText;
        } else if (typeof value1 === "object") {
            let insertText = "\n";
            for(const key in value1){
                if (Object.prototype.hasOwnProperty.call(value1, key)) {
                    const element = value1[key];
                    insertText += `${indent}\${${navOrder.index++}:${key}}:`;
                    let valueTemplate;
                    if (typeof element === "object") {
                        valueTemplate = `${this.getInsertTemplateForValue(element, indent + this.indentation, navOrder, separatorAfter)}`;
                    } else {
                        valueTemplate = ` \${${navOrder.index++}:${this.getInsertTextForPlainText(element + separatorAfter)}}
`;
                    }
                    insertText += `${valueTemplate}`;
                }
            }
            return insertText;
        }
        return this.getInsertTextForPlainText(value1 + separatorAfter);
    }
    addSchemaValueCompletions(schema4, separatorAfter, collector, types, completionType, isArray) {
        if (typeof schema4 === "object") {
            this.addEnumValueCompletions(schema4, separatorAfter, collector, isArray);
            this.addDefaultValueCompletions(schema4, separatorAfter, collector);
            this.collectTypes(schema4, types);
            if (isArray && completionType === "value" && !isAnyOfAllOfOneOfType(schema4)) {
                this.addArrayItemValueCompletion(schema4, separatorAfter, collector);
            }
            if (Array.isArray(schema4.allOf)) {
                schema4.allOf.forEach((s)=>{
                    return this.addSchemaValueCompletions(s, separatorAfter, collector, types, completionType, isArray);
                });
            }
            if (Array.isArray(schema4.anyOf)) {
                schema4.anyOf.forEach((s)=>{
                    return this.addSchemaValueCompletions(s, separatorAfter, collector, types, completionType, isArray);
                });
            }
            if (Array.isArray(schema4.oneOf)) {
                schema4.oneOf.forEach((s)=>{
                    return this.addSchemaValueCompletions(s, separatorAfter, collector, types, completionType, isArray);
                });
            }
        }
    }
    collectTypes(schema4, types) {
        if (Array.isArray(schema4.enum) || isDefined2(schema4.const)) {
            return;
        }
        const type = schema4.type;
        if (Array.isArray(type)) {
            type.forEach(function(t1) {
                return types[t1] = true;
            });
        } else if (type) {
            types[type] = true;
        }
    }
    addDefaultValueCompletions(schema4, separatorAfter, collector, arrayDepth = 0) {
        let hasProposals = false;
        if (isDefined2(schema4.default)) {
            let type = schema4.type;
            let value1 = schema4.default;
            for(let i = arrayDepth; i > 0; i--){
                value1 = [
                    value1
                ];
                type = "array";
            }
            let label;
            if (typeof value1 == "object") {
                label = "Default value";
            } else {
                label = value1.toString().replace(doubleQuotesEscapeRegExp, '"');
            }
            collector.add({
                kind: this.getSuggestionKind(type),
                label,
                insertText: this.getInsertTextForValue(value1, separatorAfter, type),
                insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet,
                detail: localize9("json.suggest.default", "Default value")
            });
            hasProposals = true;
        }
        if (Array.isArray(schema4.examples)) {
            schema4.examples.forEach((example)=>{
                let type = schema4.type;
                let value1 = example;
                for(let i = arrayDepth; i > 0; i--){
                    value1 = [
                        value1
                    ];
                    type = "array";
                }
                collector.add({
                    kind: this.getSuggestionKind(type),
                    label: this.getLabelForValue(value1),
                    insertText: this.getInsertTextForValue(value1, separatorAfter, type),
                    insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet
                });
                hasProposals = true;
            });
        }
        this.collectDefaultSnippets(schema4, separatorAfter, collector, {
            newLineFirst: true,
            indentFirstObject: true,
            shouldIndentWithTab: true
        });
        if (!hasProposals && typeof schema4.items === "object" && !Array.isArray(schema4.items)) {
            this.addDefaultValueCompletions(schema4.items, separatorAfter, collector, arrayDepth + 1);
        }
    }
    addEnumValueCompletions(schema4, separatorAfter, collector, isArray) {
        if (isDefined2(schema4.const) && !isArray) {
            collector.add({
                kind: this.getSuggestionKind(schema4.type),
                label: this.getLabelForValue(schema4.const),
                insertText: this.getInsertTextForValue(schema4.const, separatorAfter, schema4.type),
                insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet,
                documentation: this.fromMarkup(schema4.markdownDescription) || schema4.description
            });
        }
        if (Array.isArray(schema4.enum)) {
            for(let i = 0, length = schema4.enum.length; i < length; i++){
                const enm = schema4.enum[i];
                let documentation = this.fromMarkup(schema4.markdownDescription) || schema4.description;
                if (schema4.markdownEnumDescriptions && i < schema4.markdownEnumDescriptions.length && this.doesSupportMarkdown()) {
                    documentation = this.fromMarkup(schema4.markdownEnumDescriptions[i]);
                } else if (schema4.enumDescriptions && i < schema4.enumDescriptions.length) {
                    documentation = schema4.enumDescriptions[i];
                }
                collector.add({
                    kind: this.getSuggestionKind(schema4.type),
                    label: this.getLabelForValue(enm),
                    insertText: this.getInsertTextForValue(enm, separatorAfter, schema4.type),
                    insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet,
                    documentation
                });
            }
        }
    }
    getLabelForValue(value1) {
        if (value1 === null) {
            return "null";
        }
        if (Array.isArray(value1)) {
            return JSON.stringify(value1);
        }
        return "" + value1;
    }
    collectDefaultSnippets(schema4, separatorAfter, collector, settings, arrayDepth = 0) {
        if (Array.isArray(schema4.defaultSnippets)) {
            for (const s of schema4.defaultSnippets){
                let type = schema4.type;
                let value1 = s.body;
                let label = s.label;
                let insertText;
                let filterText;
                if (isDefined2(value1)) {
                    const type2 = s.type || schema4.type;
                    if (arrayDepth === 0 && type2 === "array") {
                        const fixedObj = {};
                        Object.keys(value1).forEach((val, index)=>{
                            if (index === 0 && !val.startsWith("-")) {
                                fixedObj[`- ${val}`] = value1[val];
                            } else {
                                fixedObj[`  ${val}`] = value1[val];
                            }
                        });
                        value1 = fixedObj;
                    }
                    const existingProps = Object.keys(collector.proposed).filter((proposedProp)=>collector.proposed[proposedProp].label === existingProposeItem);
                    insertText = this.getInsertTextForSnippetValue(value1, separatorAfter, settings, existingProps);
                    if (insertText === "" && value1) {
                        continue;
                    }
                    label = label || this.getLabelForSnippetValue(value1);
                } else if (typeof s.bodyText === "string") {
                    let prefix = "", suffix = "", indent = "";
                    for(let i = arrayDepth; i > 0; i--){
                        prefix = prefix + indent + "[\n";
                        suffix = suffix + "\n" + indent + "]";
                        indent += this.indentation;
                        type = "array";
                    }
                    insertText = prefix + indent + s.bodyText.split("\n").join("\n" + indent) + suffix + separatorAfter;
                    label = label || insertText;
                    filterText = insertText.replace(/[\n]/g, "");
                }
                collector.add({
                    kind: s.suggestionKind || this.getSuggestionKind(type),
                    label,
                    sortText: s.sortText || s.label,
                    documentation: this.fromMarkup(s.markdownDescription) || s.description,
                    insertText,
                    insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet,
                    filterText
                });
            }
        }
    }
    getInsertTextForSnippetValue(value1, separatorAfter, settings, existingProps, depth) {
        const replacer = (value2)=>{
            if (typeof value2 === "string") {
                if (value2[0] === "^") {
                    return value2.substr(1);
                }
                if (value2 === "true" || value2 === "false") {
                    return `"${value2}"`;
                }
            }
            return value2;
        };
        return stringifyObject2(value1, "", replacer, {
            ...settings,
            indentation: this.indentation,
            existingProps
        }, depth) + separatorAfter;
    }
    addBooleanValueCompletion(value1, separatorAfter, collector) {
        collector.add({
            kind: this.getSuggestionKind("boolean"),
            label: value1 ? "true" : "false",
            insertText: this.getInsertTextForValue(value1, separatorAfter, "boolean"),
            insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet,
            documentation: ""
        });
    }
    addNullValueCompletion(separatorAfter, collector) {
        collector.add({
            kind: this.getSuggestionKind("null"),
            label: "null",
            insertText: "null" + separatorAfter,
            insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet,
            documentation: ""
        });
    }
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    getLabelForSnippetValue(value1) {
        const label = JSON.stringify(value1);
        return label.replace(/\$\{\d+:([^}]+)\}|\$\d+/g, "$1");
    }
    getCustomTagValueCompletions(collector) {
        const validCustomTags = filterInvalidCustomTags(this.customTags);
        validCustomTags.forEach((validTag)=>{
            const label = validTag.split(" ")[0];
            this.addCustomTagValueCompletion(collector, " ", label);
        });
    }
    addCustomTagValueCompletion(collector, separatorAfter, label) {
        collector.add({
            kind: this.getSuggestionKind("string"),
            label,
            insertText: label + separatorAfter,
            insertTextFormat: import_vscode_languageserver_types14.InsertTextFormat.Snippet,
            documentation: ""
        });
    }
    getDocumentationWithMarkdownText(documentation, insertText) {
        let res = documentation;
        if (this.doesSupportMarkdown()) {
            insertText = insertText.replace(/\${[0-9]+[:|](.*)}/g, (s, arg)=>{
                return arg;
            }).replace(/\$([0-9]+)/g, "");
            res = this.fromMarkup(`${documentation}
 \`\`\`
${insertText}
\`\`\``);
        }
        return res;
    }
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    getSuggestionKind(type) {
        if (Array.isArray(type)) {
            const array = type;
            type = array.length > 0 ? array[0] : null;
        }
        if (!type) {
            return import_vscode_languageserver_types14.CompletionItemKind.Value;
        }
        switch(type){
            case "string":
                return import_vscode_languageserver_types14.CompletionItemKind.Value;
            case "object":
                return import_vscode_languageserver_types14.CompletionItemKind.Module;
            case "property":
                return import_vscode_languageserver_types14.CompletionItemKind.Property;
            default:
                return import_vscode_languageserver_types14.CompletionItemKind.Value;
        }
    }
    getCurrentWord(doc, offset) {
        let i = offset - 1;
        const text = doc.getText();
        while(i >= 0 && ' 	\n\r\v":{[,]}'.indexOf(text.charAt(i)) === -1){
            i--;
        }
        return text.substring(i + 1, offset);
    }
    fromMarkup(markupString) {
        if (markupString && this.doesSupportMarkdown()) {
            return {
                kind: import_vscode_languageserver_types14.MarkupKind.Markdown,
                value: markupString
            };
        }
        return void 0;
    }
    doesSupportMarkdown() {
        if (this.supportsMarkdown === void 0) {
            const completion = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.completion;
            this.supportsMarkdown = completion && completion.completionItem && Array.isArray(completion.completionItem.documentationFormat) && completion.completionItem.documentationFormat.indexOf(import_vscode_languageserver_types14.MarkupKind.Markdown) !== -1;
        }
        return this.supportsMarkdown;
    }
    findItemAtOffset(seqNode, doc, offset) {
        for(let i = seqNode.items.length - 1; i >= 0; i--){
            const node = seqNode.items[i];
            if (isNode(node)) {
                if (node.range) {
                    if (offset > node.range[1]) {
                        return i;
                    } else if (offset >= node.range[0]) {
                        return i;
                    }
                }
            }
        }
        return 0;
    }
    constructor(schemaService, clientCapabilities = {}, yamlDocument, telemetry){
        this.schemaService = schemaService;
        this.clientCapabilities = clientCapabilities;
        this.yamlDocument = yamlDocument;
        this.telemetry = telemetry;
        this.completionEnabled = true;
        this.arrayPrefixIndentation = "";
    }
};
var isNumberExp = /^\d+$/;
function convertToStringValue(param) {
    let value1;
    if (typeof param === "string") {
        value1 = param;
    } else {
        value1 = "" + param;
    }
    if (value1.length === 0) {
        return value1;
    }
    if (value1 === "true" || value1 === "false" || value1 === "null" || isNumberExp.test(value1)) {
        return `"${value1}"`;
    }
    if (value1.indexOf('"') !== -1) {
        value1 = value1.replace(doubleQuotesEscapeRegExp, '"');
    }
    let doQuote = !isNaN(parseInt(value1)) || value1.charAt(0) === "@";
    if (!doQuote) {
        let idx = value1.indexOf(":", 0);
        for(; idx > 0 && idx < value1.length; idx = value1.indexOf(":", idx + 1)){
            if (idx === value1.length - 1) {
                doQuote = true;
                break;
            }
            const nextChar = value1.charAt(idx + 1);
            if (nextChar === "	" || nextChar === " ") {
                doQuote = true;
                break;
            }
        }
    }
    if (doQuote) {
        value1 = `"${value1}"`;
    }
    return value1;
}
function evaluateTab1Symbol(value1) {
    return value1.replace(/\$\{1:(.*)\}/, "$1");
}
function isParentCompletionItem(item) {
    return "parent" in item;
}
// src/fillers/schemaSelectionHandlers.js
function JSONSchemaSelection() {}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlDefinition.js
var import_vscode_languageserver_types15 = __toESM(require_main());
var YamlDefinition = class {
    getDefinition(document2, params) {
        var _a;
        try {
            const yamlDocument = yamlDocumentsCache.getYamlDocument(document2);
            const offset = document2.offsetAt(params.position);
            const currentDoc = matchOffsetToDocument(offset, yamlDocument);
            if (currentDoc) {
                const [node] = currentDoc.getNodeFromPosition(offset, new TextBuffer(document2));
                if (node && isAlias(node)) {
                    const defNode = node.resolve(currentDoc.internalDocument);
                    if (defNode && defNode.range) {
                        const targetRange = import_vscode_languageserver_types15.Range.create(document2.positionAt(defNode.range[0]), document2.positionAt(defNode.range[2]));
                        const selectionRange = import_vscode_languageserver_types15.Range.create(document2.positionAt(defNode.range[0]), document2.positionAt(defNode.range[1]));
                        return [
                            import_vscode_languageserver_types15.LocationLink.create(document2.uri, targetRange, selectionRange)
                        ];
                    }
                }
            }
        } catch (err) {
            (_a = this.telemetry) == null ? void 0 : _a.sendError("yaml.definition.error", {
                error: convertErrorToTelemetryMsg(err)
            });
        }
        return void 0;
    }
    constructor(telemetry){
        this.telemetry = telemetry;
    }
};
// ../../node_modules/yaml-language-server/lib/esm/languageservice/services/yamlSelectionRanges.js
var import_vscode_languageserver_types16 = __toESM(require_main());
function getSelectionRanges2(document2, positions) {
    if (!document2) {
        return;
    }
    const doc = yamlDocumentsCache.getYamlDocument(document2);
    return positions.map((position)=>{
        const ranges = getRanges(position);
        let current;
        for (const range of ranges){
            current = import_vscode_languageserver_types16.SelectionRange.create(range, current);
        }
        if (!current) {
            current = import_vscode_languageserver_types16.SelectionRange.create({
                start: position,
                end: position
            });
        }
        return current;
    });
    function getRanges(position) {
        const offset = document2.offsetAt(position);
        const result = [];
        for (const ymlDoc of doc.documents){
            let currentNode;
            let firstNodeOffset;
            let isFirstNode = true;
            ymlDoc.visit((node)=>{
                const endOffset = node.offset + node.length;
                if (endOffset < offset) {
                    return true;
                }
                let startOffset = node.offset;
                if (startOffset > offset) {
                    const nodePosition = document2.positionAt(startOffset);
                    if (nodePosition.line !== position.line) {
                        return true;
                    }
                    const lineBeginning = {
                        line: nodePosition.line,
                        character: 0
                    };
                    const text = document2.getText({
                        start: lineBeginning,
                        end: nodePosition
                    });
                    if (text.trim().length !== 0) {
                        return true;
                    }
                    startOffset = document2.offsetAt(lineBeginning);
                    if (startOffset > offset) {
                        return true;
                    }
                }
                if (!currentNode || startOffset >= currentNode.offset) {
                    currentNode = node;
                    firstNodeOffset = startOffset;
                }
                return true;
            });
            while(currentNode){
                const startOffset = isFirstNode ? firstNodeOffset : currentNode.offset;
                const endOffset = currentNode.offset + currentNode.length;
                const range = {
                    start: document2.positionAt(startOffset),
                    end: document2.positionAt(endOffset)
                };
                const text = document2.getText(range);
                const trimmedText = text.trimEnd();
                const trimmedLength = text.length - trimmedText.length;
                if (trimmedLength > 0) {
                    range.end = document2.positionAt(endOffset - trimmedLength);
                }
                const isSurroundedBy = (startCharacter, endCharacter)=>{
                    return trimmedText.startsWith(startCharacter) && trimmedText.endsWith(endCharacter || startCharacter);
                };
                if (currentNode.type === "string" && (isSurroundedBy("'") || isSurroundedBy('"')) || currentNode.type === "object" && isSurroundedBy("{", "}") || currentNode.type === "array" && isSurroundedBy("[", "]")) {
                    result.push({
                        start: document2.positionAt(startOffset + 1),
                        end: document2.positionAt(endOffset - 1)
                    });
                }
                result.push(range);
                currentNode = currentNode.parent;
                isFirstNode = false;
            }
            if (result.length > 0) {
                break;
            }
        }
        return result.reverse();
    }
}
// ../../node_modules/yaml-language-server/lib/esm/languageservice/yamlLanguageService.js
var SchemaPriority;
(function(SchemaPriority2) {
    SchemaPriority2[SchemaPriority2["SchemaStore"] = 1] = "SchemaStore";
    SchemaPriority2[SchemaPriority2["SchemaAssociation"] = 2] = "SchemaAssociation";
    SchemaPriority2[SchemaPriority2["Settings"] = 3] = "Settings";
})(SchemaPriority || (SchemaPriority = {}));
function getLanguageService(params) {
    const schemaService = new YAMLSchemaService(params.schemaRequestService, params.workspaceContext);
    const completer = new YamlCompletion(schemaService, params.clientCapabilities, yamlDocumentsCache, params.telemetry);
    const hover = new YAMLHover(schemaService, params.telemetry);
    const yamlDocumentSymbols = new YAMLDocumentSymbols(schemaService, params.telemetry);
    const yamlValidation = new YAMLValidation(schemaService, params.telemetry);
    const formatter = new YAMLFormatter();
    const yamlCodeActions = new YamlCodeActions(params.clientCapabilities);
    const yamlCodeLens = new YamlCodeLens(schemaService, params.telemetry);
    const yamlLinks = new YamlLinks(params.telemetry);
    const yamlDefinition = new YamlDefinition(params.telemetry);
    new JSONSchemaSelection(schemaService, params.yamlSettings, params.connection);
    return {
        configure: (settings)=>{
            schemaService.clearExternalSchemas();
            if (settings.schemas) {
                schemaService.schemaPriorityMapping = /* @__PURE__ */ new Map();
                settings.schemas.forEach((settings2)=>{
                    const currPriority = settings2.priority ? settings2.priority : 0;
                    schemaService.addSchemaPriority(settings2.uri, currPriority);
                    schemaService.registerExternalSchema(settings2.uri, settings2.fileMatch, settings2.schema, settings2.name, settings2.description, settings2.versions);
                });
            }
            yamlValidation.configure(settings);
            hover.configure(settings);
            completer.configure(settings);
            formatter.configure(settings);
            yamlCodeActions.configure(settings);
        },
        registerCustomSchemaProvider: (schemaProvider)=>{
            schemaService.registerCustomSchemaProvider(schemaProvider);
        },
        findLinks: yamlLinks.findLinks.bind(yamlLinks),
        doComplete: completer.doComplete.bind(completer),
        doValidation: yamlValidation.doValidation.bind(yamlValidation),
        doHover: hover.doHover.bind(hover),
        findDocumentSymbols: yamlDocumentSymbols.findDocumentSymbols.bind(yamlDocumentSymbols),
        findDocumentSymbols2: yamlDocumentSymbols.findHierarchicalDocumentSymbols.bind(yamlDocumentSymbols),
        doDefinition: yamlDefinition.getDefinition.bind(yamlDefinition),
        resetSchema: (uri)=>{
            return schemaService.onResourceChange(uri);
        },
        doFormat: formatter.format.bind(formatter),
        doDocumentOnTypeFormatting,
        addSchema: (schemaID, schema4)=>{
            return schemaService.saveSchema(schemaID, schema4);
        },
        deleteSchema: (schemaID)=>{
            return schemaService.deleteSchema(schemaID);
        },
        modifySchemaContent: (schemaAdditions)=>{
            return schemaService.addContent(schemaAdditions);
        },
        deleteSchemaContent: (schemaDeletions)=>{
            return schemaService.deleteContent(schemaDeletions);
        },
        deleteSchemasWhole: (schemaDeletions)=>{
            return schemaService.deleteSchemas(schemaDeletions);
        },
        getFoldingRanges: getFoldingRanges2,
        getSelectionRanges: getSelectionRanges2,
        getCodeAction: (document2, params2)=>{
            return yamlCodeActions.getCodeAction(document2, params2);
        },
        getCodeLens: (document2)=>{
            return yamlCodeLens.getCodeLens(document2);
        },
        resolveCodeLens: (param)=>yamlCodeLens.resolveCodeLens(param)
    };
}
// ../../node_modules/yaml-language-server/lib/esm/yamlSettings.js
var import_vscode_languageserver = __toESM(require_main4());
var SettingsState = class {
    constructor(){
        this.yamlConfigurationSettings = void 0;
        this.schemaAssociations = void 0;
        this.formatterRegistration = null;
        this.specificValidatorPaths = [];
        this.schemaConfigurationSettings = [];
        this.yamlShouldValidate = true;
        this.yamlFormatterSettings = {
            singleQuote: false,
            bracketSpacing: true,
            proseWrap: "preserve",
            printWidth: 80,
            enable: true
        };
        this.yamlShouldHover = true;
        this.yamlShouldCompletion = true;
        this.schemaStoreSettings = [];
        this.customTags = [];
        this.schemaStoreEnabled = true;
        this.schemaStoreUrl = JSON_SCHEMASTORE_URL;
        this.indentation = void 0;
        this.disableAdditionalProperties = false;
        this.disableDefaultProperties = false;
        this.suggest = {
            parentSkeletonSelectedFirst: false
        };
        this.keyOrdering = false;
        this.maxItemsComputed = 5e3;
        this.pendingValidationRequests = {};
        this.validationDelayMs = 200;
        this.documents = new import_vscode_languageserver.TextDocuments(TextDocument);
        this.workspaceRoot = null;
        this.workspaceFolders = [];
        this.clientDynamicRegisterSupport = false;
        this.hierarchicalDocumentSymbolSupport = false;
        this.hasWorkspaceFolderCapability = false;
        this.hasConfigurationCapability = false;
        this.useVSCodeContentRequest = false;
        this.yamlVersion = "1.2";
        this.useSchemaSelectionRequests = false;
        this.hasWsChangeWatchedFileDynamicRegistration = false;
        this.fileExtensions = [
            ".yml",
            ".yaml"
        ];
    }
};
 /*! Bundled license information:

lodash/lodash.js:
  (**
   * @license
   * Lodash <https://lodash.com/>
   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
   * Released under MIT license <https://lodash.com/license>
   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
   *)
*/ 

// 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/yaml/yaml-service.ts
function yaml_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 YamlService extends base_service.BaseService {
    $getYamlSchemaUri(sessionID) {
        return this.getOption(sessionID, "schemaUri");
    }
    addDocument(document) {
        super.addDocument(document);
        this.$configureService(document.uri);
    }
    $configureService(sessionID) {
        var _schemas;
        let schemas = this.getOption(sessionID, "schemas");
        (_schemas = schemas) === null || _schemas === void 0 ? void 0 : _schemas.forEach((el)=>{
            if (el.uri === this.$getYamlSchemaUri(sessionID)) {
                var _el;
                var _fileMatch;
                (_fileMatch = (_el = el).fileMatch) !== null && _fileMatch !== void 0 ? _fileMatch : _el.fileMatch = [];
                el.fileMatch.push(sessionID);
            }
            var _el_schema;
            let schema = (_el_schema = el.schema) !== null && _el_schema !== void 0 ? _el_schema : this.schemas[el.uri];
            if (schema) this.schemas[el.uri] = schema;
            this.$service.resetSchema(el.uri);
            el.schema = undefined;
        });
        this.$service.configure({
            schemas: schemas,
            hover: true,
            validate: true,
            completion: true,
            format: true,
            customTags: false
        });
    }
    removeDocument(document) {
        var _schemas;
        super.removeDocument(document);
        let schemas = this.getOption(document.uri, "schemas");
        (_schemas = schemas) === null || _schemas === void 0 ? void 0 : _schemas.forEach((el)=>{
            if (el.uri === this.$getYamlSchemaUri(document.uri)) {
                var _el_fileMatch;
                el.fileMatch = (_el_fileMatch = el.fileMatch) === null || _el_fileMatch === void 0 ? void 0 : _el_fileMatch.filter((pattern)=>pattern != document.uri);
            }
        });
        this.$service.configure({
            schemas: schemas
        });
    }
    setOptions(sessionID, options, merge = false) {
        super.setOptions(sessionID, options, merge);
        this.$configureService(sessionID);
    }
    setGlobalOptions(options) {
        super.setGlobalOptions(options);
        this.$configureService("");
    }
    format(document, range, options) {
        let fullDocument = this.getDocument(document.uri);
        if (!fullDocument) return Promise.resolve([]);
        return Promise.resolve(this.$service.doFormat(fullDocument, {})); //TODO: options?
    }
    async doHover(document, position) {
        let fullDocument = this.getDocument(document.uri);
        if (!fullDocument) return null;
        return this.$service.doHover(fullDocument, position);
    }
    async doValidation(document) {
        let fullDocument = this.getDocument(document.uri);
        if (!fullDocument) return [];
        return filterDiagnostics(await this.$service.doValidation(fullDocument, false), this.optionsToFilterDiagnostics);
    }
    async doComplete(document, position) {
        let fullDocument = this.getDocument(document.uri);
        if (!fullDocument) return null;
        return this.$service.doComplete(fullDocument, position, false);
    }
    async doResolve(item) {
        return item;
    }
    constructor(mode){
        super(mode);
        yaml_service_define_property(this, "$service", void 0);
        yaml_service_define_property(this, "schemas", {});
        yaml_service_define_property(this, "serviceCapabilities", {
            completionProvider: {
                resolveProvider: true
            },
            diagnosticProvider: {
                interFileDependencies: true,
                workspaceDiagnostics: true
            },
            documentRangeFormattingProvider: true,
            documentFormattingProvider: true,
            hoverProvider: true
        });
        this.$service = getLanguageService({
            schemaRequestService: (uri)=>{
                uri = uri.replace("file:///", "");
                let jsonSchema = this.schemas[uri];
                if (jsonSchema) return Promise.resolve(jsonSchema);
                return Promise.reject(`Unable to load schema at ${uri}`);
            },
            workspaceContext: {
                resolveRelativePath: (relativePath, resource)=>{
                    return relativePath + resource;
                }
            },
            // @ts-ignore
            clientCapabilities: this.clientCapabilities
        });
    }
}

})();

/******/ 	return __webpack_exports__;
/******/ })()
;
});