5464da9c6e
Initialize Tauri iOS support with conditional compilation: - Desktop-only features (git CLI, menu, MCP, Claude CLI) gated behind #[cfg(desktop)] - Mobile stubs return graceful errors so frontend degrades smoothly - Vault read/write, AI chat, search, settings work unchanged on both platforms - Xcode project generated, Rust cross-compiles cleanly to aarch64-apple-ios-sim - All 581 Rust tests and 2201 frontend tests still pass Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
7381 lines
256 KiB
JavaScript
Executable File
7381 lines
256 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
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 __commonJS = (cb, mod) => function __require() {
|
|
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/constants.js
|
|
var require_constants = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/constants.js"(exports2, module2) {
|
|
"use strict";
|
|
var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
|
|
var hasBlob = typeof Blob !== "undefined";
|
|
if (hasBlob) BINARY_TYPES.push("blob");
|
|
module2.exports = {
|
|
BINARY_TYPES,
|
|
CLOSE_TIMEOUT: 3e4,
|
|
EMPTY_BUFFER: Buffer.alloc(0),
|
|
GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
|
|
hasBlob,
|
|
kForOnEventAttribute: /* @__PURE__ */ Symbol("kIsForOnEventAttribute"),
|
|
kListener: /* @__PURE__ */ Symbol("kListener"),
|
|
kStatusCode: /* @__PURE__ */ Symbol("status-code"),
|
|
kWebSocket: /* @__PURE__ */ Symbol("websocket"),
|
|
NOOP: () => {
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/buffer-util.js
|
|
var require_buffer_util = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/buffer-util.js"(exports2, module2) {
|
|
"use strict";
|
|
var { EMPTY_BUFFER } = require_constants();
|
|
var FastBuffer = Buffer[Symbol.species];
|
|
function concat(list, totalLength) {
|
|
if (list.length === 0) return EMPTY_BUFFER;
|
|
if (list.length === 1) return list[0];
|
|
const target = Buffer.allocUnsafe(totalLength);
|
|
let offset = 0;
|
|
for (let i = 0; i < list.length; i++) {
|
|
const buf = list[i];
|
|
target.set(buf, offset);
|
|
offset += buf.length;
|
|
}
|
|
if (offset < totalLength) {
|
|
return new FastBuffer(target.buffer, target.byteOffset, offset);
|
|
}
|
|
return target;
|
|
}
|
|
function _mask(source, mask, output, offset, length) {
|
|
for (let i = 0; i < length; i++) {
|
|
output[offset + i] = source[i] ^ mask[i & 3];
|
|
}
|
|
}
|
|
function _unmask(buffer, mask) {
|
|
for (let i = 0; i < buffer.length; i++) {
|
|
buffer[i] ^= mask[i & 3];
|
|
}
|
|
}
|
|
function toArrayBuffer(buf) {
|
|
if (buf.length === buf.buffer.byteLength) {
|
|
return buf.buffer;
|
|
}
|
|
return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
|
|
}
|
|
function toBuffer(data) {
|
|
toBuffer.readOnly = true;
|
|
if (Buffer.isBuffer(data)) return data;
|
|
let buf;
|
|
if (data instanceof ArrayBuffer) {
|
|
buf = new FastBuffer(data);
|
|
} else if (ArrayBuffer.isView(data)) {
|
|
buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
|
|
} else {
|
|
buf = Buffer.from(data);
|
|
toBuffer.readOnly = false;
|
|
}
|
|
return buf;
|
|
}
|
|
module2.exports = {
|
|
concat,
|
|
mask: _mask,
|
|
toArrayBuffer,
|
|
toBuffer,
|
|
unmask: _unmask
|
|
};
|
|
if (!process.env.WS_NO_BUFFER_UTIL) {
|
|
try {
|
|
const bufferUtil = require("bufferutil");
|
|
module2.exports.mask = function(source, mask, output, offset, length) {
|
|
if (length < 48) _mask(source, mask, output, offset, length);
|
|
else bufferUtil.mask(source, mask, output, offset, length);
|
|
};
|
|
module2.exports.unmask = function(buffer, mask) {
|
|
if (buffer.length < 32) _unmask(buffer, mask);
|
|
else bufferUtil.unmask(buffer, mask);
|
|
};
|
|
} catch (e) {
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/limiter.js
|
|
var require_limiter = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/limiter.js"(exports2, module2) {
|
|
"use strict";
|
|
var kDone = /* @__PURE__ */ Symbol("kDone");
|
|
var kRun = /* @__PURE__ */ Symbol("kRun");
|
|
var Limiter = class {
|
|
/**
|
|
* Creates a new `Limiter`.
|
|
*
|
|
* @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
|
|
* to run concurrently
|
|
*/
|
|
constructor(concurrency) {
|
|
this[kDone] = () => {
|
|
this.pending--;
|
|
this[kRun]();
|
|
};
|
|
this.concurrency = concurrency || Infinity;
|
|
this.jobs = [];
|
|
this.pending = 0;
|
|
}
|
|
/**
|
|
* Adds a job to the queue.
|
|
*
|
|
* @param {Function} job The job to run
|
|
* @public
|
|
*/
|
|
add(job) {
|
|
this.jobs.push(job);
|
|
this[kRun]();
|
|
}
|
|
/**
|
|
* Removes a job from the queue and runs it if possible.
|
|
*
|
|
* @private
|
|
*/
|
|
[kRun]() {
|
|
if (this.pending === this.concurrency) return;
|
|
if (this.jobs.length) {
|
|
const job = this.jobs.shift();
|
|
this.pending++;
|
|
job(this[kDone]);
|
|
}
|
|
}
|
|
};
|
|
module2.exports = Limiter;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/permessage-deflate.js
|
|
var require_permessage_deflate = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/permessage-deflate.js"(exports2, module2) {
|
|
"use strict";
|
|
var zlib = require("zlib");
|
|
var bufferUtil = require_buffer_util();
|
|
var Limiter = require_limiter();
|
|
var { kStatusCode } = require_constants();
|
|
var FastBuffer = Buffer[Symbol.species];
|
|
var TRAILER = Buffer.from([0, 0, 255, 255]);
|
|
var kPerMessageDeflate = /* @__PURE__ */ Symbol("permessage-deflate");
|
|
var kTotalLength = /* @__PURE__ */ Symbol("total-length");
|
|
var kCallback = /* @__PURE__ */ Symbol("callback");
|
|
var kBuffers = /* @__PURE__ */ Symbol("buffers");
|
|
var kError = /* @__PURE__ */ Symbol("error");
|
|
var zlibLimiter;
|
|
var PerMessageDeflate = class {
|
|
/**
|
|
* Creates a PerMessageDeflate instance.
|
|
*
|
|
* @param {Object} [options] Configuration options
|
|
* @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
|
|
* for, or request, a custom client window size
|
|
* @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
|
|
* acknowledge disabling of client context takeover
|
|
* @param {Number} [options.concurrencyLimit=10] The number of concurrent
|
|
* calls to zlib
|
|
* @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
|
|
* use of a custom server window size
|
|
* @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
|
|
* disabling of server context takeover
|
|
* @param {Number} [options.threshold=1024] Size (in bytes) below which
|
|
* messages should not be compressed if context takeover is disabled
|
|
* @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
|
|
* deflate
|
|
* @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
|
|
* inflate
|
|
* @param {Boolean} [isServer=false] Create the instance in either server or
|
|
* client mode
|
|
* @param {Number} [maxPayload=0] The maximum allowed message length
|
|
*/
|
|
constructor(options2, isServer, maxPayload) {
|
|
this._maxPayload = maxPayload | 0;
|
|
this._options = options2 || {};
|
|
this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
|
|
this._isServer = !!isServer;
|
|
this._deflate = null;
|
|
this._inflate = null;
|
|
this.params = null;
|
|
if (!zlibLimiter) {
|
|
const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
|
|
zlibLimiter = new Limiter(concurrency);
|
|
}
|
|
}
|
|
/**
|
|
* @type {String}
|
|
*/
|
|
static get extensionName() {
|
|
return "permessage-deflate";
|
|
}
|
|
/**
|
|
* Create an extension negotiation offer.
|
|
*
|
|
* @return {Object} Extension parameters
|
|
* @public
|
|
*/
|
|
offer() {
|
|
const params = {};
|
|
if (this._options.serverNoContextTakeover) {
|
|
params.server_no_context_takeover = true;
|
|
}
|
|
if (this._options.clientNoContextTakeover) {
|
|
params.client_no_context_takeover = true;
|
|
}
|
|
if (this._options.serverMaxWindowBits) {
|
|
params.server_max_window_bits = this._options.serverMaxWindowBits;
|
|
}
|
|
if (this._options.clientMaxWindowBits) {
|
|
params.client_max_window_bits = this._options.clientMaxWindowBits;
|
|
} else if (this._options.clientMaxWindowBits == null) {
|
|
params.client_max_window_bits = true;
|
|
}
|
|
return params;
|
|
}
|
|
/**
|
|
* Accept an extension negotiation offer/response.
|
|
*
|
|
* @param {Array} configurations The extension negotiation offers/reponse
|
|
* @return {Object} Accepted configuration
|
|
* @public
|
|
*/
|
|
accept(configurations) {
|
|
configurations = this.normalizeParams(configurations);
|
|
this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
|
|
return this.params;
|
|
}
|
|
/**
|
|
* Releases all resources used by the extension.
|
|
*
|
|
* @public
|
|
*/
|
|
cleanup() {
|
|
if (this._inflate) {
|
|
this._inflate.close();
|
|
this._inflate = null;
|
|
}
|
|
if (this._deflate) {
|
|
const callback = this._deflate[kCallback];
|
|
this._deflate.close();
|
|
this._deflate = null;
|
|
if (callback) {
|
|
callback(
|
|
new Error(
|
|
"The deflate stream was closed while data was being processed"
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Accept an extension negotiation offer.
|
|
*
|
|
* @param {Array} offers The extension negotiation offers
|
|
* @return {Object} Accepted configuration
|
|
* @private
|
|
*/
|
|
acceptAsServer(offers) {
|
|
const opts = this._options;
|
|
const accepted = offers.find((params) => {
|
|
if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
if (!accepted) {
|
|
throw new Error("None of the extension offers can be accepted");
|
|
}
|
|
if (opts.serverNoContextTakeover) {
|
|
accepted.server_no_context_takeover = true;
|
|
}
|
|
if (opts.clientNoContextTakeover) {
|
|
accepted.client_no_context_takeover = true;
|
|
}
|
|
if (typeof opts.serverMaxWindowBits === "number") {
|
|
accepted.server_max_window_bits = opts.serverMaxWindowBits;
|
|
}
|
|
if (typeof opts.clientMaxWindowBits === "number") {
|
|
accepted.client_max_window_bits = opts.clientMaxWindowBits;
|
|
} else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
|
|
delete accepted.client_max_window_bits;
|
|
}
|
|
return accepted;
|
|
}
|
|
/**
|
|
* Accept the extension negotiation response.
|
|
*
|
|
* @param {Array} response The extension negotiation response
|
|
* @return {Object} Accepted configuration
|
|
* @private
|
|
*/
|
|
acceptAsClient(response) {
|
|
const params = response[0];
|
|
if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
|
|
throw new Error('Unexpected parameter "client_no_context_takeover"');
|
|
}
|
|
if (!params.client_max_window_bits) {
|
|
if (typeof this._options.clientMaxWindowBits === "number") {
|
|
params.client_max_window_bits = this._options.clientMaxWindowBits;
|
|
}
|
|
} else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
|
|
throw new Error(
|
|
'Unexpected or invalid parameter "client_max_window_bits"'
|
|
);
|
|
}
|
|
return params;
|
|
}
|
|
/**
|
|
* Normalize parameters.
|
|
*
|
|
* @param {Array} configurations The extension negotiation offers/reponse
|
|
* @return {Array} The offers/response with normalized parameters
|
|
* @private
|
|
*/
|
|
normalizeParams(configurations) {
|
|
configurations.forEach((params) => {
|
|
Object.keys(params).forEach((key) => {
|
|
let value = params[key];
|
|
if (value.length > 1) {
|
|
throw new Error(`Parameter "${key}" must have only a single value`);
|
|
}
|
|
value = value[0];
|
|
if (key === "client_max_window_bits") {
|
|
if (value !== true) {
|
|
const num = +value;
|
|
if (!Number.isInteger(num) || num < 8 || num > 15) {
|
|
throw new TypeError(
|
|
`Invalid value for parameter "${key}": ${value}`
|
|
);
|
|
}
|
|
value = num;
|
|
} else if (!this._isServer) {
|
|
throw new TypeError(
|
|
`Invalid value for parameter "${key}": ${value}`
|
|
);
|
|
}
|
|
} else if (key === "server_max_window_bits") {
|
|
const num = +value;
|
|
if (!Number.isInteger(num) || num < 8 || num > 15) {
|
|
throw new TypeError(
|
|
`Invalid value for parameter "${key}": ${value}`
|
|
);
|
|
}
|
|
value = num;
|
|
} else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
|
|
if (value !== true) {
|
|
throw new TypeError(
|
|
`Invalid value for parameter "${key}": ${value}`
|
|
);
|
|
}
|
|
} else {
|
|
throw new Error(`Unknown parameter "${key}"`);
|
|
}
|
|
params[key] = value;
|
|
});
|
|
});
|
|
return configurations;
|
|
}
|
|
/**
|
|
* Decompress data. Concurrency limited.
|
|
*
|
|
* @param {Buffer} data Compressed data
|
|
* @param {Boolean} fin Specifies whether or not this is the last fragment
|
|
* @param {Function} callback Callback
|
|
* @public
|
|
*/
|
|
decompress(data, fin, callback) {
|
|
zlibLimiter.add((done) => {
|
|
this._decompress(data, fin, (err, result) => {
|
|
done();
|
|
callback(err, result);
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Compress data. Concurrency limited.
|
|
*
|
|
* @param {(Buffer|String)} data Data to compress
|
|
* @param {Boolean} fin Specifies whether or not this is the last fragment
|
|
* @param {Function} callback Callback
|
|
* @public
|
|
*/
|
|
compress(data, fin, callback) {
|
|
zlibLimiter.add((done) => {
|
|
this._compress(data, fin, (err, result) => {
|
|
done();
|
|
callback(err, result);
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Decompress data.
|
|
*
|
|
* @param {Buffer} data Compressed data
|
|
* @param {Boolean} fin Specifies whether or not this is the last fragment
|
|
* @param {Function} callback Callback
|
|
* @private
|
|
*/
|
|
_decompress(data, fin, callback) {
|
|
const endpoint = this._isServer ? "client" : "server";
|
|
if (!this._inflate) {
|
|
const key = `${endpoint}_max_window_bits`;
|
|
const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
|
|
this._inflate = zlib.createInflateRaw({
|
|
...this._options.zlibInflateOptions,
|
|
windowBits
|
|
});
|
|
this._inflate[kPerMessageDeflate] = this;
|
|
this._inflate[kTotalLength] = 0;
|
|
this._inflate[kBuffers] = [];
|
|
this._inflate.on("error", inflateOnError);
|
|
this._inflate.on("data", inflateOnData);
|
|
}
|
|
this._inflate[kCallback] = callback;
|
|
this._inflate.write(data);
|
|
if (fin) this._inflate.write(TRAILER);
|
|
this._inflate.flush(() => {
|
|
const err = this._inflate[kError];
|
|
if (err) {
|
|
this._inflate.close();
|
|
this._inflate = null;
|
|
callback(err);
|
|
return;
|
|
}
|
|
const data2 = bufferUtil.concat(
|
|
this._inflate[kBuffers],
|
|
this._inflate[kTotalLength]
|
|
);
|
|
if (this._inflate._readableState.endEmitted) {
|
|
this._inflate.close();
|
|
this._inflate = null;
|
|
} else {
|
|
this._inflate[kTotalLength] = 0;
|
|
this._inflate[kBuffers] = [];
|
|
if (fin && this.params[`${endpoint}_no_context_takeover`]) {
|
|
this._inflate.reset();
|
|
}
|
|
}
|
|
callback(null, data2);
|
|
});
|
|
}
|
|
/**
|
|
* Compress data.
|
|
*
|
|
* @param {(Buffer|String)} data Data to compress
|
|
* @param {Boolean} fin Specifies whether or not this is the last fragment
|
|
* @param {Function} callback Callback
|
|
* @private
|
|
*/
|
|
_compress(data, fin, callback) {
|
|
const endpoint = this._isServer ? "server" : "client";
|
|
if (!this._deflate) {
|
|
const key = `${endpoint}_max_window_bits`;
|
|
const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
|
|
this._deflate = zlib.createDeflateRaw({
|
|
...this._options.zlibDeflateOptions,
|
|
windowBits
|
|
});
|
|
this._deflate[kTotalLength] = 0;
|
|
this._deflate[kBuffers] = [];
|
|
this._deflate.on("data", deflateOnData);
|
|
}
|
|
this._deflate[kCallback] = callback;
|
|
this._deflate.write(data);
|
|
this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
|
|
if (!this._deflate) {
|
|
return;
|
|
}
|
|
let data2 = bufferUtil.concat(
|
|
this._deflate[kBuffers],
|
|
this._deflate[kTotalLength]
|
|
);
|
|
if (fin) {
|
|
data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4);
|
|
}
|
|
this._deflate[kCallback] = null;
|
|
this._deflate[kTotalLength] = 0;
|
|
this._deflate[kBuffers] = [];
|
|
if (fin && this.params[`${endpoint}_no_context_takeover`]) {
|
|
this._deflate.reset();
|
|
}
|
|
callback(null, data2);
|
|
});
|
|
}
|
|
};
|
|
module2.exports = PerMessageDeflate;
|
|
function deflateOnData(chunk) {
|
|
this[kBuffers].push(chunk);
|
|
this[kTotalLength] += chunk.length;
|
|
}
|
|
function inflateOnData(chunk) {
|
|
this[kTotalLength] += chunk.length;
|
|
if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
|
|
this[kBuffers].push(chunk);
|
|
return;
|
|
}
|
|
this[kError] = new RangeError("Max payload size exceeded");
|
|
this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
|
|
this[kError][kStatusCode] = 1009;
|
|
this.removeListener("data", inflateOnData);
|
|
this.reset();
|
|
}
|
|
function inflateOnError(err) {
|
|
this[kPerMessageDeflate]._inflate = null;
|
|
if (this[kError]) {
|
|
this[kCallback](this[kError]);
|
|
return;
|
|
}
|
|
err[kStatusCode] = 1007;
|
|
this[kCallback](err);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/validation.js
|
|
var require_validation = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/validation.js"(exports2, module2) {
|
|
"use strict";
|
|
var { isUtf8 } = require("buffer");
|
|
var { hasBlob } = require_constants();
|
|
var tokenChars = [
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
// 0 - 15
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
// 16 - 31
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
// 32 - 47
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
// 48 - 63
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
// 64 - 79
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
// 80 - 95
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
// 96 - 111
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0
|
|
// 112 - 127
|
|
];
|
|
function isValidStatusCode(code) {
|
|
return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
|
|
}
|
|
function _isValidUTF8(buf) {
|
|
const len = buf.length;
|
|
let i = 0;
|
|
while (i < len) {
|
|
if ((buf[i] & 128) === 0) {
|
|
i++;
|
|
} else if ((buf[i] & 224) === 192) {
|
|
if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) {
|
|
return false;
|
|
}
|
|
i += 2;
|
|
} else if ((buf[i] & 240) === 224) {
|
|
if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || // Overlong
|
|
buf[i] === 237 && (buf[i + 1] & 224) === 160) {
|
|
return false;
|
|
}
|
|
i += 3;
|
|
} else if ((buf[i] & 248) === 240) {
|
|
if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || // Overlong
|
|
buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) {
|
|
return false;
|
|
}
|
|
i += 4;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isBlob(value) {
|
|
return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File");
|
|
}
|
|
module2.exports = {
|
|
isBlob,
|
|
isValidStatusCode,
|
|
isValidUTF8: _isValidUTF8,
|
|
tokenChars
|
|
};
|
|
if (isUtf8) {
|
|
module2.exports.isValidUTF8 = function(buf) {
|
|
return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
|
|
};
|
|
} else if (!process.env.WS_NO_UTF_8_VALIDATE) {
|
|
try {
|
|
const isValidUTF8 = require("utf-8-validate");
|
|
module2.exports.isValidUTF8 = function(buf) {
|
|
return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
|
|
};
|
|
} catch (e) {
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/receiver.js
|
|
var require_receiver = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/receiver.js"(exports2, module2) {
|
|
"use strict";
|
|
var { Writable } = require("stream");
|
|
var PerMessageDeflate = require_permessage_deflate();
|
|
var {
|
|
BINARY_TYPES,
|
|
EMPTY_BUFFER,
|
|
kStatusCode,
|
|
kWebSocket
|
|
} = require_constants();
|
|
var { concat, toArrayBuffer, unmask } = require_buffer_util();
|
|
var { isValidStatusCode, isValidUTF8 } = require_validation();
|
|
var FastBuffer = Buffer[Symbol.species];
|
|
var GET_INFO = 0;
|
|
var GET_PAYLOAD_LENGTH_16 = 1;
|
|
var GET_PAYLOAD_LENGTH_64 = 2;
|
|
var GET_MASK = 3;
|
|
var GET_DATA = 4;
|
|
var INFLATING = 5;
|
|
var DEFER_EVENT = 6;
|
|
var Receiver2 = class extends Writable {
|
|
/**
|
|
* Creates a Receiver instance.
|
|
*
|
|
* @param {Object} [options] Options object
|
|
* @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
|
|
* any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
|
|
* multiple times in the same tick
|
|
* @param {String} [options.binaryType=nodebuffer] The type for binary data
|
|
* @param {Object} [options.extensions] An object containing the negotiated
|
|
* extensions
|
|
* @param {Boolean} [options.isServer=false] Specifies whether to operate in
|
|
* client or server mode
|
|
* @param {Number} [options.maxPayload=0] The maximum allowed message length
|
|
* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
|
|
* not to skip UTF-8 validation for text and close messages
|
|
*/
|
|
constructor(options2 = {}) {
|
|
super();
|
|
this._allowSynchronousEvents = options2.allowSynchronousEvents !== void 0 ? options2.allowSynchronousEvents : true;
|
|
this._binaryType = options2.binaryType || BINARY_TYPES[0];
|
|
this._extensions = options2.extensions || {};
|
|
this._isServer = !!options2.isServer;
|
|
this._maxPayload = options2.maxPayload | 0;
|
|
this._skipUTF8Validation = !!options2.skipUTF8Validation;
|
|
this[kWebSocket] = void 0;
|
|
this._bufferedBytes = 0;
|
|
this._buffers = [];
|
|
this._compressed = false;
|
|
this._payloadLength = 0;
|
|
this._mask = void 0;
|
|
this._fragmented = 0;
|
|
this._masked = false;
|
|
this._fin = false;
|
|
this._opcode = 0;
|
|
this._totalPayloadLength = 0;
|
|
this._messageLength = 0;
|
|
this._fragments = [];
|
|
this._errored = false;
|
|
this._loop = false;
|
|
this._state = GET_INFO;
|
|
}
|
|
/**
|
|
* Implements `Writable.prototype._write()`.
|
|
*
|
|
* @param {Buffer} chunk The chunk of data to write
|
|
* @param {String} encoding The character encoding of `chunk`
|
|
* @param {Function} cb Callback
|
|
* @private
|
|
*/
|
|
_write(chunk, encoding, cb) {
|
|
if (this._opcode === 8 && this._state == GET_INFO) return cb();
|
|
this._bufferedBytes += chunk.length;
|
|
this._buffers.push(chunk);
|
|
this.startLoop(cb);
|
|
}
|
|
/**
|
|
* Consumes `n` bytes from the buffered data.
|
|
*
|
|
* @param {Number} n The number of bytes to consume
|
|
* @return {Buffer} The consumed bytes
|
|
* @private
|
|
*/
|
|
consume(n) {
|
|
this._bufferedBytes -= n;
|
|
if (n === this._buffers[0].length) return this._buffers.shift();
|
|
if (n < this._buffers[0].length) {
|
|
const buf = this._buffers[0];
|
|
this._buffers[0] = new FastBuffer(
|
|
buf.buffer,
|
|
buf.byteOffset + n,
|
|
buf.length - n
|
|
);
|
|
return new FastBuffer(buf.buffer, buf.byteOffset, n);
|
|
}
|
|
const dst = Buffer.allocUnsafe(n);
|
|
do {
|
|
const buf = this._buffers[0];
|
|
const offset = dst.length - n;
|
|
if (n >= buf.length) {
|
|
dst.set(this._buffers.shift(), offset);
|
|
} else {
|
|
dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
|
|
this._buffers[0] = new FastBuffer(
|
|
buf.buffer,
|
|
buf.byteOffset + n,
|
|
buf.length - n
|
|
);
|
|
}
|
|
n -= buf.length;
|
|
} while (n > 0);
|
|
return dst;
|
|
}
|
|
/**
|
|
* Starts the parsing loop.
|
|
*
|
|
* @param {Function} cb Callback
|
|
* @private
|
|
*/
|
|
startLoop(cb) {
|
|
this._loop = true;
|
|
do {
|
|
switch (this._state) {
|
|
case GET_INFO:
|
|
this.getInfo(cb);
|
|
break;
|
|
case GET_PAYLOAD_LENGTH_16:
|
|
this.getPayloadLength16(cb);
|
|
break;
|
|
case GET_PAYLOAD_LENGTH_64:
|
|
this.getPayloadLength64(cb);
|
|
break;
|
|
case GET_MASK:
|
|
this.getMask();
|
|
break;
|
|
case GET_DATA:
|
|
this.getData(cb);
|
|
break;
|
|
case INFLATING:
|
|
case DEFER_EVENT:
|
|
this._loop = false;
|
|
return;
|
|
}
|
|
} while (this._loop);
|
|
if (!this._errored) cb();
|
|
}
|
|
/**
|
|
* Reads the first two bytes of a frame.
|
|
*
|
|
* @param {Function} cb Callback
|
|
* @private
|
|
*/
|
|
getInfo(cb) {
|
|
if (this._bufferedBytes < 2) {
|
|
this._loop = false;
|
|
return;
|
|
}
|
|
const buf = this.consume(2);
|
|
if ((buf[0] & 48) !== 0) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"RSV2 and RSV3 must be clear",
|
|
true,
|
|
1002,
|
|
"WS_ERR_UNEXPECTED_RSV_2_3"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
const compressed = (buf[0] & 64) === 64;
|
|
if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"RSV1 must be clear",
|
|
true,
|
|
1002,
|
|
"WS_ERR_UNEXPECTED_RSV_1"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
this._fin = (buf[0] & 128) === 128;
|
|
this._opcode = buf[0] & 15;
|
|
this._payloadLength = buf[1] & 127;
|
|
if (this._opcode === 0) {
|
|
if (compressed) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"RSV1 must be clear",
|
|
true,
|
|
1002,
|
|
"WS_ERR_UNEXPECTED_RSV_1"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
if (!this._fragmented) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"invalid opcode 0",
|
|
true,
|
|
1002,
|
|
"WS_ERR_INVALID_OPCODE"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
this._opcode = this._fragmented;
|
|
} else if (this._opcode === 1 || this._opcode === 2) {
|
|
if (this._fragmented) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
`invalid opcode ${this._opcode}`,
|
|
true,
|
|
1002,
|
|
"WS_ERR_INVALID_OPCODE"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
this._compressed = compressed;
|
|
} else if (this._opcode > 7 && this._opcode < 11) {
|
|
if (!this._fin) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"FIN must be set",
|
|
true,
|
|
1002,
|
|
"WS_ERR_EXPECTED_FIN"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
if (compressed) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"RSV1 must be clear",
|
|
true,
|
|
1002,
|
|
"WS_ERR_UNEXPECTED_RSV_1"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
`invalid payload length ${this._payloadLength}`,
|
|
true,
|
|
1002,
|
|
"WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
} else {
|
|
const error = this.createError(
|
|
RangeError,
|
|
`invalid opcode ${this._opcode}`,
|
|
true,
|
|
1002,
|
|
"WS_ERR_INVALID_OPCODE"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
|
|
this._masked = (buf[1] & 128) === 128;
|
|
if (this._isServer) {
|
|
if (!this._masked) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"MASK must be set",
|
|
true,
|
|
1002,
|
|
"WS_ERR_EXPECTED_MASK"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
} else if (this._masked) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"MASK must be clear",
|
|
true,
|
|
1002,
|
|
"WS_ERR_UNEXPECTED_MASK"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
|
|
else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
|
|
else this.haveLength(cb);
|
|
}
|
|
/**
|
|
* Gets extended payload length (7+16).
|
|
*
|
|
* @param {Function} cb Callback
|
|
* @private
|
|
*/
|
|
getPayloadLength16(cb) {
|
|
if (this._bufferedBytes < 2) {
|
|
this._loop = false;
|
|
return;
|
|
}
|
|
this._payloadLength = this.consume(2).readUInt16BE(0);
|
|
this.haveLength(cb);
|
|
}
|
|
/**
|
|
* Gets extended payload length (7+64).
|
|
*
|
|
* @param {Function} cb Callback
|
|
* @private
|
|
*/
|
|
getPayloadLength64(cb) {
|
|
if (this._bufferedBytes < 8) {
|
|
this._loop = false;
|
|
return;
|
|
}
|
|
const buf = this.consume(8);
|
|
const num = buf.readUInt32BE(0);
|
|
if (num > Math.pow(2, 53 - 32) - 1) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"Unsupported WebSocket frame: payload length > 2^53 - 1",
|
|
false,
|
|
1009,
|
|
"WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
|
|
this.haveLength(cb);
|
|
}
|
|
/**
|
|
* Payload length has been read.
|
|
*
|
|
* @param {Function} cb Callback
|
|
* @private
|
|
*/
|
|
haveLength(cb) {
|
|
if (this._payloadLength && this._opcode < 8) {
|
|
this._totalPayloadLength += this._payloadLength;
|
|
if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"Max payload size exceeded",
|
|
false,
|
|
1009,
|
|
"WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
}
|
|
if (this._masked) this._state = GET_MASK;
|
|
else this._state = GET_DATA;
|
|
}
|
|
/**
|
|
* Reads mask bytes.
|
|
*
|
|
* @private
|
|
*/
|
|
getMask() {
|
|
if (this._bufferedBytes < 4) {
|
|
this._loop = false;
|
|
return;
|
|
}
|
|
this._mask = this.consume(4);
|
|
this._state = GET_DATA;
|
|
}
|
|
/**
|
|
* Reads data bytes.
|
|
*
|
|
* @param {Function} cb Callback
|
|
* @private
|
|
*/
|
|
getData(cb) {
|
|
let data = EMPTY_BUFFER;
|
|
if (this._payloadLength) {
|
|
if (this._bufferedBytes < this._payloadLength) {
|
|
this._loop = false;
|
|
return;
|
|
}
|
|
data = this.consume(this._payloadLength);
|
|
if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) {
|
|
unmask(data, this._mask);
|
|
}
|
|
}
|
|
if (this._opcode > 7) {
|
|
this.controlMessage(data, cb);
|
|
return;
|
|
}
|
|
if (this._compressed) {
|
|
this._state = INFLATING;
|
|
this.decompress(data, cb);
|
|
return;
|
|
}
|
|
if (data.length) {
|
|
this._messageLength = this._totalPayloadLength;
|
|
this._fragments.push(data);
|
|
}
|
|
this.dataMessage(cb);
|
|
}
|
|
/**
|
|
* Decompresses data.
|
|
*
|
|
* @param {Buffer} data Compressed data
|
|
* @param {Function} cb Callback
|
|
* @private
|
|
*/
|
|
decompress(data, cb) {
|
|
const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
|
|
perMessageDeflate.decompress(data, this._fin, (err, buf) => {
|
|
if (err) return cb(err);
|
|
if (buf.length) {
|
|
this._messageLength += buf.length;
|
|
if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
"Max payload size exceeded",
|
|
false,
|
|
1009,
|
|
"WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
this._fragments.push(buf);
|
|
}
|
|
this.dataMessage(cb);
|
|
if (this._state === GET_INFO) this.startLoop(cb);
|
|
});
|
|
}
|
|
/**
|
|
* Handles a data message.
|
|
*
|
|
* @param {Function} cb Callback
|
|
* @private
|
|
*/
|
|
dataMessage(cb) {
|
|
if (!this._fin) {
|
|
this._state = GET_INFO;
|
|
return;
|
|
}
|
|
const messageLength = this._messageLength;
|
|
const fragments = this._fragments;
|
|
this._totalPayloadLength = 0;
|
|
this._messageLength = 0;
|
|
this._fragmented = 0;
|
|
this._fragments = [];
|
|
if (this._opcode === 2) {
|
|
let data;
|
|
if (this._binaryType === "nodebuffer") {
|
|
data = concat(fragments, messageLength);
|
|
} else if (this._binaryType === "arraybuffer") {
|
|
data = toArrayBuffer(concat(fragments, messageLength));
|
|
} else if (this._binaryType === "blob") {
|
|
data = new Blob(fragments);
|
|
} else {
|
|
data = fragments;
|
|
}
|
|
if (this._allowSynchronousEvents) {
|
|
this.emit("message", data, true);
|
|
this._state = GET_INFO;
|
|
} else {
|
|
this._state = DEFER_EVENT;
|
|
setImmediate(() => {
|
|
this.emit("message", data, true);
|
|
this._state = GET_INFO;
|
|
this.startLoop(cb);
|
|
});
|
|
}
|
|
} else {
|
|
const buf = concat(fragments, messageLength);
|
|
if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
|
|
const error = this.createError(
|
|
Error,
|
|
"invalid UTF-8 sequence",
|
|
true,
|
|
1007,
|
|
"WS_ERR_INVALID_UTF8"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
if (this._state === INFLATING || this._allowSynchronousEvents) {
|
|
this.emit("message", buf, false);
|
|
this._state = GET_INFO;
|
|
} else {
|
|
this._state = DEFER_EVENT;
|
|
setImmediate(() => {
|
|
this.emit("message", buf, false);
|
|
this._state = GET_INFO;
|
|
this.startLoop(cb);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Handles a control message.
|
|
*
|
|
* @param {Buffer} data Data to handle
|
|
* @return {(Error|RangeError|undefined)} A possible error
|
|
* @private
|
|
*/
|
|
controlMessage(data, cb) {
|
|
if (this._opcode === 8) {
|
|
if (data.length === 0) {
|
|
this._loop = false;
|
|
this.emit("conclude", 1005, EMPTY_BUFFER);
|
|
this.end();
|
|
} else {
|
|
const code = data.readUInt16BE(0);
|
|
if (!isValidStatusCode(code)) {
|
|
const error = this.createError(
|
|
RangeError,
|
|
`invalid status code ${code}`,
|
|
true,
|
|
1002,
|
|
"WS_ERR_INVALID_CLOSE_CODE"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
const buf = new FastBuffer(
|
|
data.buffer,
|
|
data.byteOffset + 2,
|
|
data.length - 2
|
|
);
|
|
if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
|
|
const error = this.createError(
|
|
Error,
|
|
"invalid UTF-8 sequence",
|
|
true,
|
|
1007,
|
|
"WS_ERR_INVALID_UTF8"
|
|
);
|
|
cb(error);
|
|
return;
|
|
}
|
|
this._loop = false;
|
|
this.emit("conclude", code, buf);
|
|
this.end();
|
|
}
|
|
this._state = GET_INFO;
|
|
return;
|
|
}
|
|
if (this._allowSynchronousEvents) {
|
|
this.emit(this._opcode === 9 ? "ping" : "pong", data);
|
|
this._state = GET_INFO;
|
|
} else {
|
|
this._state = DEFER_EVENT;
|
|
setImmediate(() => {
|
|
this.emit(this._opcode === 9 ? "ping" : "pong", data);
|
|
this._state = GET_INFO;
|
|
this.startLoop(cb);
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Builds an error object.
|
|
*
|
|
* @param {function(new:Error|RangeError)} ErrorCtor The error constructor
|
|
* @param {String} message The error message
|
|
* @param {Boolean} prefix Specifies whether or not to add a default prefix to
|
|
* `message`
|
|
* @param {Number} statusCode The status code
|
|
* @param {String} errorCode The exposed error code
|
|
* @return {(Error|RangeError)} The error
|
|
* @private
|
|
*/
|
|
createError(ErrorCtor, message, prefix, statusCode, errorCode) {
|
|
this._loop = false;
|
|
this._errored = true;
|
|
const err = new ErrorCtor(
|
|
prefix ? `Invalid WebSocket frame: ${message}` : message
|
|
);
|
|
Error.captureStackTrace(err, this.createError);
|
|
err.code = errorCode;
|
|
err[kStatusCode] = statusCode;
|
|
return err;
|
|
}
|
|
};
|
|
module2.exports = Receiver2;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/sender.js
|
|
var require_sender = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/sender.js"(exports2, module2) {
|
|
"use strict";
|
|
var { Duplex } = require("stream");
|
|
var { randomFillSync } = require("crypto");
|
|
var PerMessageDeflate = require_permessage_deflate();
|
|
var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
|
|
var { isBlob, isValidStatusCode } = require_validation();
|
|
var { mask: applyMask, toBuffer } = require_buffer_util();
|
|
var kByteLength = /* @__PURE__ */ Symbol("kByteLength");
|
|
var maskBuffer = Buffer.alloc(4);
|
|
var RANDOM_POOL_SIZE = 8 * 1024;
|
|
var randomPool;
|
|
var randomPoolPointer = RANDOM_POOL_SIZE;
|
|
var DEFAULT = 0;
|
|
var DEFLATING = 1;
|
|
var GET_BLOB_DATA = 2;
|
|
var Sender2 = class _Sender {
|
|
/**
|
|
* Creates a Sender instance.
|
|
*
|
|
* @param {Duplex} socket The connection socket
|
|
* @param {Object} [extensions] An object containing the negotiated extensions
|
|
* @param {Function} [generateMask] The function used to generate the masking
|
|
* key
|
|
*/
|
|
constructor(socket, extensions, generateMask) {
|
|
this._extensions = extensions || {};
|
|
if (generateMask) {
|
|
this._generateMask = generateMask;
|
|
this._maskBuffer = Buffer.alloc(4);
|
|
}
|
|
this._socket = socket;
|
|
this._firstFragment = true;
|
|
this._compress = false;
|
|
this._bufferedBytes = 0;
|
|
this._queue = [];
|
|
this._state = DEFAULT;
|
|
this.onerror = NOOP;
|
|
this[kWebSocket] = void 0;
|
|
}
|
|
/**
|
|
* Frames a piece of data according to the HyBi WebSocket protocol.
|
|
*
|
|
* @param {(Buffer|String)} data The data to frame
|
|
* @param {Object} options Options object
|
|
* @param {Boolean} [options.fin=false] Specifies whether or not to set the
|
|
* FIN bit
|
|
* @param {Function} [options.generateMask] The function used to generate the
|
|
* masking key
|
|
* @param {Boolean} [options.mask=false] Specifies whether or not to mask
|
|
* `data`
|
|
* @param {Buffer} [options.maskBuffer] The buffer used to store the masking
|
|
* key
|
|
* @param {Number} options.opcode The opcode
|
|
* @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
|
|
* modified
|
|
* @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
|
|
* RSV1 bit
|
|
* @return {(Buffer|String)[]} The framed data
|
|
* @public
|
|
*/
|
|
static frame(data, options2) {
|
|
let mask;
|
|
let merge = false;
|
|
let offset = 2;
|
|
let skipMasking = false;
|
|
if (options2.mask) {
|
|
mask = options2.maskBuffer || maskBuffer;
|
|
if (options2.generateMask) {
|
|
options2.generateMask(mask);
|
|
} else {
|
|
if (randomPoolPointer === RANDOM_POOL_SIZE) {
|
|
if (randomPool === void 0) {
|
|
randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
|
|
}
|
|
randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
|
|
randomPoolPointer = 0;
|
|
}
|
|
mask[0] = randomPool[randomPoolPointer++];
|
|
mask[1] = randomPool[randomPoolPointer++];
|
|
mask[2] = randomPool[randomPoolPointer++];
|
|
mask[3] = randomPool[randomPoolPointer++];
|
|
}
|
|
skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
|
|
offset = 6;
|
|
}
|
|
let dataLength;
|
|
if (typeof data === "string") {
|
|
if ((!options2.mask || skipMasking) && options2[kByteLength] !== void 0) {
|
|
dataLength = options2[kByteLength];
|
|
} else {
|
|
data = Buffer.from(data);
|
|
dataLength = data.length;
|
|
}
|
|
} else {
|
|
dataLength = data.length;
|
|
merge = options2.mask && options2.readOnly && !skipMasking;
|
|
}
|
|
let payloadLength = dataLength;
|
|
if (dataLength >= 65536) {
|
|
offset += 8;
|
|
payloadLength = 127;
|
|
} else if (dataLength > 125) {
|
|
offset += 2;
|
|
payloadLength = 126;
|
|
}
|
|
const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
|
|
target[0] = options2.fin ? options2.opcode | 128 : options2.opcode;
|
|
if (options2.rsv1) target[0] |= 64;
|
|
target[1] = payloadLength;
|
|
if (payloadLength === 126) {
|
|
target.writeUInt16BE(dataLength, 2);
|
|
} else if (payloadLength === 127) {
|
|
target[2] = target[3] = 0;
|
|
target.writeUIntBE(dataLength, 4, 6);
|
|
}
|
|
if (!options2.mask) return [target, data];
|
|
target[1] |= 128;
|
|
target[offset - 4] = mask[0];
|
|
target[offset - 3] = mask[1];
|
|
target[offset - 2] = mask[2];
|
|
target[offset - 1] = mask[3];
|
|
if (skipMasking) return [target, data];
|
|
if (merge) {
|
|
applyMask(data, mask, target, offset, dataLength);
|
|
return [target];
|
|
}
|
|
applyMask(data, mask, data, 0, dataLength);
|
|
return [target, data];
|
|
}
|
|
/**
|
|
* Sends a close message to the other peer.
|
|
*
|
|
* @param {Number} [code] The status code component of the body
|
|
* @param {(String|Buffer)} [data] The message component of the body
|
|
* @param {Boolean} [mask=false] Specifies whether or not to mask the message
|
|
* @param {Function} [cb] Callback
|
|
* @public
|
|
*/
|
|
close(code, data, mask, cb) {
|
|
let buf;
|
|
if (code === void 0) {
|
|
buf = EMPTY_BUFFER;
|
|
} else if (typeof code !== "number" || !isValidStatusCode(code)) {
|
|
throw new TypeError("First argument must be a valid error code number");
|
|
} else if (data === void 0 || !data.length) {
|
|
buf = Buffer.allocUnsafe(2);
|
|
buf.writeUInt16BE(code, 0);
|
|
} else {
|
|
const length = Buffer.byteLength(data);
|
|
if (length > 123) {
|
|
throw new RangeError("The message must not be greater than 123 bytes");
|
|
}
|
|
buf = Buffer.allocUnsafe(2 + length);
|
|
buf.writeUInt16BE(code, 0);
|
|
if (typeof data === "string") {
|
|
buf.write(data, 2);
|
|
} else {
|
|
buf.set(data, 2);
|
|
}
|
|
}
|
|
const options2 = {
|
|
[kByteLength]: buf.length,
|
|
fin: true,
|
|
generateMask: this._generateMask,
|
|
mask,
|
|
maskBuffer: this._maskBuffer,
|
|
opcode: 8,
|
|
readOnly: false,
|
|
rsv1: false
|
|
};
|
|
if (this._state !== DEFAULT) {
|
|
this.enqueue([this.dispatch, buf, false, options2, cb]);
|
|
} else {
|
|
this.sendFrame(_Sender.frame(buf, options2), cb);
|
|
}
|
|
}
|
|
/**
|
|
* Sends a ping message to the other peer.
|
|
*
|
|
* @param {*} data The message to send
|
|
* @param {Boolean} [mask=false] Specifies whether or not to mask `data`
|
|
* @param {Function} [cb] Callback
|
|
* @public
|
|
*/
|
|
ping(data, mask, cb) {
|
|
let byteLength;
|
|
let readOnly;
|
|
if (typeof data === "string") {
|
|
byteLength = Buffer.byteLength(data);
|
|
readOnly = false;
|
|
} else if (isBlob(data)) {
|
|
byteLength = data.size;
|
|
readOnly = false;
|
|
} else {
|
|
data = toBuffer(data);
|
|
byteLength = data.length;
|
|
readOnly = toBuffer.readOnly;
|
|
}
|
|
if (byteLength > 125) {
|
|
throw new RangeError("The data size must not be greater than 125 bytes");
|
|
}
|
|
const options2 = {
|
|
[kByteLength]: byteLength,
|
|
fin: true,
|
|
generateMask: this._generateMask,
|
|
mask,
|
|
maskBuffer: this._maskBuffer,
|
|
opcode: 9,
|
|
readOnly,
|
|
rsv1: false
|
|
};
|
|
if (isBlob(data)) {
|
|
if (this._state !== DEFAULT) {
|
|
this.enqueue([this.getBlobData, data, false, options2, cb]);
|
|
} else {
|
|
this.getBlobData(data, false, options2, cb);
|
|
}
|
|
} else if (this._state !== DEFAULT) {
|
|
this.enqueue([this.dispatch, data, false, options2, cb]);
|
|
} else {
|
|
this.sendFrame(_Sender.frame(data, options2), cb);
|
|
}
|
|
}
|
|
/**
|
|
* Sends a pong message to the other peer.
|
|
*
|
|
* @param {*} data The message to send
|
|
* @param {Boolean} [mask=false] Specifies whether or not to mask `data`
|
|
* @param {Function} [cb] Callback
|
|
* @public
|
|
*/
|
|
pong(data, mask, cb) {
|
|
let byteLength;
|
|
let readOnly;
|
|
if (typeof data === "string") {
|
|
byteLength = Buffer.byteLength(data);
|
|
readOnly = false;
|
|
} else if (isBlob(data)) {
|
|
byteLength = data.size;
|
|
readOnly = false;
|
|
} else {
|
|
data = toBuffer(data);
|
|
byteLength = data.length;
|
|
readOnly = toBuffer.readOnly;
|
|
}
|
|
if (byteLength > 125) {
|
|
throw new RangeError("The data size must not be greater than 125 bytes");
|
|
}
|
|
const options2 = {
|
|
[kByteLength]: byteLength,
|
|
fin: true,
|
|
generateMask: this._generateMask,
|
|
mask,
|
|
maskBuffer: this._maskBuffer,
|
|
opcode: 10,
|
|
readOnly,
|
|
rsv1: false
|
|
};
|
|
if (isBlob(data)) {
|
|
if (this._state !== DEFAULT) {
|
|
this.enqueue([this.getBlobData, data, false, options2, cb]);
|
|
} else {
|
|
this.getBlobData(data, false, options2, cb);
|
|
}
|
|
} else if (this._state !== DEFAULT) {
|
|
this.enqueue([this.dispatch, data, false, options2, cb]);
|
|
} else {
|
|
this.sendFrame(_Sender.frame(data, options2), cb);
|
|
}
|
|
}
|
|
/**
|
|
* Sends a data message to the other peer.
|
|
*
|
|
* @param {*} data The message to send
|
|
* @param {Object} options Options object
|
|
* @param {Boolean} [options.binary=false] Specifies whether `data` is binary
|
|
* or text
|
|
* @param {Boolean} [options.compress=false] Specifies whether or not to
|
|
* compress `data`
|
|
* @param {Boolean} [options.fin=false] Specifies whether the fragment is the
|
|
* last one
|
|
* @param {Boolean} [options.mask=false] Specifies whether or not to mask
|
|
* `data`
|
|
* @param {Function} [cb] Callback
|
|
* @public
|
|
*/
|
|
send(data, options2, cb) {
|
|
const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
|
|
let opcode = options2.binary ? 2 : 1;
|
|
let rsv1 = options2.compress;
|
|
let byteLength;
|
|
let readOnly;
|
|
if (typeof data === "string") {
|
|
byteLength = Buffer.byteLength(data);
|
|
readOnly = false;
|
|
} else if (isBlob(data)) {
|
|
byteLength = data.size;
|
|
readOnly = false;
|
|
} else {
|
|
data = toBuffer(data);
|
|
byteLength = data.length;
|
|
readOnly = toBuffer.readOnly;
|
|
}
|
|
if (this._firstFragment) {
|
|
this._firstFragment = false;
|
|
if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) {
|
|
rsv1 = byteLength >= perMessageDeflate._threshold;
|
|
}
|
|
this._compress = rsv1;
|
|
} else {
|
|
rsv1 = false;
|
|
opcode = 0;
|
|
}
|
|
if (options2.fin) this._firstFragment = true;
|
|
const opts = {
|
|
[kByteLength]: byteLength,
|
|
fin: options2.fin,
|
|
generateMask: this._generateMask,
|
|
mask: options2.mask,
|
|
maskBuffer: this._maskBuffer,
|
|
opcode,
|
|
readOnly,
|
|
rsv1
|
|
};
|
|
if (isBlob(data)) {
|
|
if (this._state !== DEFAULT) {
|
|
this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
|
|
} else {
|
|
this.getBlobData(data, this._compress, opts, cb);
|
|
}
|
|
} else if (this._state !== DEFAULT) {
|
|
this.enqueue([this.dispatch, data, this._compress, opts, cb]);
|
|
} else {
|
|
this.dispatch(data, this._compress, opts, cb);
|
|
}
|
|
}
|
|
/**
|
|
* Gets the contents of a blob as binary data.
|
|
*
|
|
* @param {Blob} blob The blob
|
|
* @param {Boolean} [compress=false] Specifies whether or not to compress
|
|
* the data
|
|
* @param {Object} options Options object
|
|
* @param {Boolean} [options.fin=false] Specifies whether or not to set the
|
|
* FIN bit
|
|
* @param {Function} [options.generateMask] The function used to generate the
|
|
* masking key
|
|
* @param {Boolean} [options.mask=false] Specifies whether or not to mask
|
|
* `data`
|
|
* @param {Buffer} [options.maskBuffer] The buffer used to store the masking
|
|
* key
|
|
* @param {Number} options.opcode The opcode
|
|
* @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
|
|
* modified
|
|
* @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
|
|
* RSV1 bit
|
|
* @param {Function} [cb] Callback
|
|
* @private
|
|
*/
|
|
getBlobData(blob, compress, options2, cb) {
|
|
this._bufferedBytes += options2[kByteLength];
|
|
this._state = GET_BLOB_DATA;
|
|
blob.arrayBuffer().then((arrayBuffer) => {
|
|
if (this._socket.destroyed) {
|
|
const err = new Error(
|
|
"The socket was closed while the blob was being read"
|
|
);
|
|
process.nextTick(callCallbacks, this, err, cb);
|
|
return;
|
|
}
|
|
this._bufferedBytes -= options2[kByteLength];
|
|
const data = toBuffer(arrayBuffer);
|
|
if (!compress) {
|
|
this._state = DEFAULT;
|
|
this.sendFrame(_Sender.frame(data, options2), cb);
|
|
this.dequeue();
|
|
} else {
|
|
this.dispatch(data, compress, options2, cb);
|
|
}
|
|
}).catch((err) => {
|
|
process.nextTick(onError, this, err, cb);
|
|
});
|
|
}
|
|
/**
|
|
* Dispatches a message.
|
|
*
|
|
* @param {(Buffer|String)} data The message to send
|
|
* @param {Boolean} [compress=false] Specifies whether or not to compress
|
|
* `data`
|
|
* @param {Object} options Options object
|
|
* @param {Boolean} [options.fin=false] Specifies whether or not to set the
|
|
* FIN bit
|
|
* @param {Function} [options.generateMask] The function used to generate the
|
|
* masking key
|
|
* @param {Boolean} [options.mask=false] Specifies whether or not to mask
|
|
* `data`
|
|
* @param {Buffer} [options.maskBuffer] The buffer used to store the masking
|
|
* key
|
|
* @param {Number} options.opcode The opcode
|
|
* @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
|
|
* modified
|
|
* @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
|
|
* RSV1 bit
|
|
* @param {Function} [cb] Callback
|
|
* @private
|
|
*/
|
|
dispatch(data, compress, options2, cb) {
|
|
if (!compress) {
|
|
this.sendFrame(_Sender.frame(data, options2), cb);
|
|
return;
|
|
}
|
|
const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
|
|
this._bufferedBytes += options2[kByteLength];
|
|
this._state = DEFLATING;
|
|
perMessageDeflate.compress(data, options2.fin, (_, buf) => {
|
|
if (this._socket.destroyed) {
|
|
const err = new Error(
|
|
"The socket was closed while data was being compressed"
|
|
);
|
|
callCallbacks(this, err, cb);
|
|
return;
|
|
}
|
|
this._bufferedBytes -= options2[kByteLength];
|
|
this._state = DEFAULT;
|
|
options2.readOnly = false;
|
|
this.sendFrame(_Sender.frame(buf, options2), cb);
|
|
this.dequeue();
|
|
});
|
|
}
|
|
/**
|
|
* Executes queued send operations.
|
|
*
|
|
* @private
|
|
*/
|
|
dequeue() {
|
|
while (this._state === DEFAULT && this._queue.length) {
|
|
const params = this._queue.shift();
|
|
this._bufferedBytes -= params[3][kByteLength];
|
|
Reflect.apply(params[0], this, params.slice(1));
|
|
}
|
|
}
|
|
/**
|
|
* Enqueues a send operation.
|
|
*
|
|
* @param {Array} params Send operation parameters.
|
|
* @private
|
|
*/
|
|
enqueue(params) {
|
|
this._bufferedBytes += params[3][kByteLength];
|
|
this._queue.push(params);
|
|
}
|
|
/**
|
|
* Sends a frame.
|
|
*
|
|
* @param {(Buffer | String)[]} list The frame to send
|
|
* @param {Function} [cb] Callback
|
|
* @private
|
|
*/
|
|
sendFrame(list, cb) {
|
|
if (list.length === 2) {
|
|
this._socket.cork();
|
|
this._socket.write(list[0]);
|
|
this._socket.write(list[1], cb);
|
|
this._socket.uncork();
|
|
} else {
|
|
this._socket.write(list[0], cb);
|
|
}
|
|
}
|
|
};
|
|
module2.exports = Sender2;
|
|
function callCallbacks(sender, err, cb) {
|
|
if (typeof cb === "function") cb(err);
|
|
for (let i = 0; i < sender._queue.length; i++) {
|
|
const params = sender._queue[i];
|
|
const callback = params[params.length - 1];
|
|
if (typeof callback === "function") callback(err);
|
|
}
|
|
}
|
|
function onError(sender, err, cb) {
|
|
callCallbacks(sender, err, cb);
|
|
sender.onerror(err);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/event-target.js
|
|
var require_event_target = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/event-target.js"(exports2, module2) {
|
|
"use strict";
|
|
var { kForOnEventAttribute, kListener } = require_constants();
|
|
var kCode = /* @__PURE__ */ Symbol("kCode");
|
|
var kData = /* @__PURE__ */ Symbol("kData");
|
|
var kError = /* @__PURE__ */ Symbol("kError");
|
|
var kMessage = /* @__PURE__ */ Symbol("kMessage");
|
|
var kReason = /* @__PURE__ */ Symbol("kReason");
|
|
var kTarget = /* @__PURE__ */ Symbol("kTarget");
|
|
var kType = /* @__PURE__ */ Symbol("kType");
|
|
var kWasClean = /* @__PURE__ */ Symbol("kWasClean");
|
|
var Event = class {
|
|
/**
|
|
* Create a new `Event`.
|
|
*
|
|
* @param {String} type The name of the event
|
|
* @throws {TypeError} If the `type` argument is not specified
|
|
*/
|
|
constructor(type) {
|
|
this[kTarget] = null;
|
|
this[kType] = type;
|
|
}
|
|
/**
|
|
* @type {*}
|
|
*/
|
|
get target() {
|
|
return this[kTarget];
|
|
}
|
|
/**
|
|
* @type {String}
|
|
*/
|
|
get type() {
|
|
return this[kType];
|
|
}
|
|
};
|
|
Object.defineProperty(Event.prototype, "target", { enumerable: true });
|
|
Object.defineProperty(Event.prototype, "type", { enumerable: true });
|
|
var CloseEvent = class extends Event {
|
|
/**
|
|
* Create a new `CloseEvent`.
|
|
*
|
|
* @param {String} type The name of the event
|
|
* @param {Object} [options] A dictionary object that allows for setting
|
|
* attributes via object members of the same name
|
|
* @param {Number} [options.code=0] The status code explaining why the
|
|
* connection was closed
|
|
* @param {String} [options.reason=''] A human-readable string explaining why
|
|
* the connection was closed
|
|
* @param {Boolean} [options.wasClean=false] Indicates whether or not the
|
|
* connection was cleanly closed
|
|
*/
|
|
constructor(type, options2 = {}) {
|
|
super(type);
|
|
this[kCode] = options2.code === void 0 ? 0 : options2.code;
|
|
this[kReason] = options2.reason === void 0 ? "" : options2.reason;
|
|
this[kWasClean] = options2.wasClean === void 0 ? false : options2.wasClean;
|
|
}
|
|
/**
|
|
* @type {Number}
|
|
*/
|
|
get code() {
|
|
return this[kCode];
|
|
}
|
|
/**
|
|
* @type {String}
|
|
*/
|
|
get reason() {
|
|
return this[kReason];
|
|
}
|
|
/**
|
|
* @type {Boolean}
|
|
*/
|
|
get wasClean() {
|
|
return this[kWasClean];
|
|
}
|
|
};
|
|
Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
|
|
Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
|
|
Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
|
|
var ErrorEvent = class extends Event {
|
|
/**
|
|
* Create a new `ErrorEvent`.
|
|
*
|
|
* @param {String} type The name of the event
|
|
* @param {Object} [options] A dictionary object that allows for setting
|
|
* attributes via object members of the same name
|
|
* @param {*} [options.error=null] The error that generated this event
|
|
* @param {String} [options.message=''] The error message
|
|
*/
|
|
constructor(type, options2 = {}) {
|
|
super(type);
|
|
this[kError] = options2.error === void 0 ? null : options2.error;
|
|
this[kMessage] = options2.message === void 0 ? "" : options2.message;
|
|
}
|
|
/**
|
|
* @type {*}
|
|
*/
|
|
get error() {
|
|
return this[kError];
|
|
}
|
|
/**
|
|
* @type {String}
|
|
*/
|
|
get message() {
|
|
return this[kMessage];
|
|
}
|
|
};
|
|
Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true });
|
|
Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true });
|
|
var MessageEvent = class extends Event {
|
|
/**
|
|
* Create a new `MessageEvent`.
|
|
*
|
|
* @param {String} type The name of the event
|
|
* @param {Object} [options] A dictionary object that allows for setting
|
|
* attributes via object members of the same name
|
|
* @param {*} [options.data=null] The message content
|
|
*/
|
|
constructor(type, options2 = {}) {
|
|
super(type);
|
|
this[kData] = options2.data === void 0 ? null : options2.data;
|
|
}
|
|
/**
|
|
* @type {*}
|
|
*/
|
|
get data() {
|
|
return this[kData];
|
|
}
|
|
};
|
|
Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
|
|
var EventTarget = {
|
|
/**
|
|
* Register an event listener.
|
|
*
|
|
* @param {String} type A string representing the event type to listen for
|
|
* @param {(Function|Object)} handler The listener to add
|
|
* @param {Object} [options] An options object specifies characteristics about
|
|
* the event listener
|
|
* @param {Boolean} [options.once=false] A `Boolean` indicating that the
|
|
* listener should be invoked at most once after being added. If `true`,
|
|
* the listener would be automatically removed when invoked.
|
|
* @public
|
|
*/
|
|
addEventListener(type, handler, options2 = {}) {
|
|
for (const listener of this.listeners(type)) {
|
|
if (!options2[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) {
|
|
return;
|
|
}
|
|
}
|
|
let wrapper;
|
|
if (type === "message") {
|
|
wrapper = function onMessage(data, isBinary) {
|
|
const event = new MessageEvent("message", {
|
|
data: isBinary ? data : data.toString()
|
|
});
|
|
event[kTarget] = this;
|
|
callListener(handler, this, event);
|
|
};
|
|
} else if (type === "close") {
|
|
wrapper = function onClose(code, message) {
|
|
const event = new CloseEvent("close", {
|
|
code,
|
|
reason: message.toString(),
|
|
wasClean: this._closeFrameReceived && this._closeFrameSent
|
|
});
|
|
event[kTarget] = this;
|
|
callListener(handler, this, event);
|
|
};
|
|
} else if (type === "error") {
|
|
wrapper = function onError(error) {
|
|
const event = new ErrorEvent("error", {
|
|
error,
|
|
message: error.message
|
|
});
|
|
event[kTarget] = this;
|
|
callListener(handler, this, event);
|
|
};
|
|
} else if (type === "open") {
|
|
wrapper = function onOpen() {
|
|
const event = new Event("open");
|
|
event[kTarget] = this;
|
|
callListener(handler, this, event);
|
|
};
|
|
} else {
|
|
return;
|
|
}
|
|
wrapper[kForOnEventAttribute] = !!options2[kForOnEventAttribute];
|
|
wrapper[kListener] = handler;
|
|
if (options2.once) {
|
|
this.once(type, wrapper);
|
|
} else {
|
|
this.on(type, wrapper);
|
|
}
|
|
},
|
|
/**
|
|
* Remove an event listener.
|
|
*
|
|
* @param {String} type A string representing the event type to remove
|
|
* @param {(Function|Object)} handler The listener to remove
|
|
* @public
|
|
*/
|
|
removeEventListener(type, handler) {
|
|
for (const listener of this.listeners(type)) {
|
|
if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
|
|
this.removeListener(type, listener);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
module2.exports = {
|
|
CloseEvent,
|
|
ErrorEvent,
|
|
Event,
|
|
EventTarget,
|
|
MessageEvent
|
|
};
|
|
function callListener(listener, thisArg, event) {
|
|
if (typeof listener === "object" && listener.handleEvent) {
|
|
listener.handleEvent.call(listener, event);
|
|
} else {
|
|
listener.call(thisArg, event);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/extension.js
|
|
var require_extension = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/extension.js"(exports2, module2) {
|
|
"use strict";
|
|
var { tokenChars } = require_validation();
|
|
function push(dest, name, elem) {
|
|
if (dest[name] === void 0) dest[name] = [elem];
|
|
else dest[name].push(elem);
|
|
}
|
|
function parse2(header) {
|
|
const offers = /* @__PURE__ */ Object.create(null);
|
|
let params = /* @__PURE__ */ Object.create(null);
|
|
let mustUnescape = false;
|
|
let isEscaping = false;
|
|
let inQuotes = false;
|
|
let extensionName;
|
|
let paramName;
|
|
let start = -1;
|
|
let code = -1;
|
|
let end = -1;
|
|
let i = 0;
|
|
for (; i < header.length; i++) {
|
|
code = header.charCodeAt(i);
|
|
if (extensionName === void 0) {
|
|
if (end === -1 && tokenChars[code] === 1) {
|
|
if (start === -1) start = i;
|
|
} else if (i !== 0 && (code === 32 || code === 9)) {
|
|
if (end === -1 && start !== -1) end = i;
|
|
} else if (code === 59 || code === 44) {
|
|
if (start === -1) {
|
|
throw new SyntaxError(`Unexpected character at index ${i}`);
|
|
}
|
|
if (end === -1) end = i;
|
|
const name = header.slice(start, end);
|
|
if (code === 44) {
|
|
push(offers, name, params);
|
|
params = /* @__PURE__ */ Object.create(null);
|
|
} else {
|
|
extensionName = name;
|
|
}
|
|
start = end = -1;
|
|
} else {
|
|
throw new SyntaxError(`Unexpected character at index ${i}`);
|
|
}
|
|
} else if (paramName === void 0) {
|
|
if (end === -1 && tokenChars[code] === 1) {
|
|
if (start === -1) start = i;
|
|
} else if (code === 32 || code === 9) {
|
|
if (end === -1 && start !== -1) end = i;
|
|
} else if (code === 59 || code === 44) {
|
|
if (start === -1) {
|
|
throw new SyntaxError(`Unexpected character at index ${i}`);
|
|
}
|
|
if (end === -1) end = i;
|
|
push(params, header.slice(start, end), true);
|
|
if (code === 44) {
|
|
push(offers, extensionName, params);
|
|
params = /* @__PURE__ */ Object.create(null);
|
|
extensionName = void 0;
|
|
}
|
|
start = end = -1;
|
|
} else if (code === 61 && start !== -1 && end === -1) {
|
|
paramName = header.slice(start, i);
|
|
start = end = -1;
|
|
} else {
|
|
throw new SyntaxError(`Unexpected character at index ${i}`);
|
|
}
|
|
} else {
|
|
if (isEscaping) {
|
|
if (tokenChars[code] !== 1) {
|
|
throw new SyntaxError(`Unexpected character at index ${i}`);
|
|
}
|
|
if (start === -1) start = i;
|
|
else if (!mustUnescape) mustUnescape = true;
|
|
isEscaping = false;
|
|
} else if (inQuotes) {
|
|
if (tokenChars[code] === 1) {
|
|
if (start === -1) start = i;
|
|
} else if (code === 34 && start !== -1) {
|
|
inQuotes = false;
|
|
end = i;
|
|
} else if (code === 92) {
|
|
isEscaping = true;
|
|
} else {
|
|
throw new SyntaxError(`Unexpected character at index ${i}`);
|
|
}
|
|
} else if (code === 34 && header.charCodeAt(i - 1) === 61) {
|
|
inQuotes = true;
|
|
} else if (end === -1 && tokenChars[code] === 1) {
|
|
if (start === -1) start = i;
|
|
} else if (start !== -1 && (code === 32 || code === 9)) {
|
|
if (end === -1) end = i;
|
|
} else if (code === 59 || code === 44) {
|
|
if (start === -1) {
|
|
throw new SyntaxError(`Unexpected character at index ${i}`);
|
|
}
|
|
if (end === -1) end = i;
|
|
let value = header.slice(start, end);
|
|
if (mustUnescape) {
|
|
value = value.replace(/\\/g, "");
|
|
mustUnescape = false;
|
|
}
|
|
push(params, paramName, value);
|
|
if (code === 44) {
|
|
push(offers, extensionName, params);
|
|
params = /* @__PURE__ */ Object.create(null);
|
|
extensionName = void 0;
|
|
}
|
|
paramName = void 0;
|
|
start = end = -1;
|
|
} else {
|
|
throw new SyntaxError(`Unexpected character at index ${i}`);
|
|
}
|
|
}
|
|
}
|
|
if (start === -1 || inQuotes || code === 32 || code === 9) {
|
|
throw new SyntaxError("Unexpected end of input");
|
|
}
|
|
if (end === -1) end = i;
|
|
const token = header.slice(start, end);
|
|
if (extensionName === void 0) {
|
|
push(offers, token, params);
|
|
} else {
|
|
if (paramName === void 0) {
|
|
push(params, token, true);
|
|
} else if (mustUnescape) {
|
|
push(params, paramName, token.replace(/\\/g, ""));
|
|
} else {
|
|
push(params, paramName, token);
|
|
}
|
|
push(offers, extensionName, params);
|
|
}
|
|
return offers;
|
|
}
|
|
function format(extensions) {
|
|
return Object.keys(extensions).map((extension) => {
|
|
let configurations = extensions[extension];
|
|
if (!Array.isArray(configurations)) configurations = [configurations];
|
|
return configurations.map((params) => {
|
|
return [extension].concat(
|
|
Object.keys(params).map((k) => {
|
|
let values = params[k];
|
|
if (!Array.isArray(values)) values = [values];
|
|
return values.map((v) => v === true ? k : `${k}=${v}`).join("; ");
|
|
})
|
|
).join("; ");
|
|
}).join(", ");
|
|
}).join(", ");
|
|
}
|
|
module2.exports = { format, parse: parse2 };
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket.js
|
|
var require_websocket = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket.js"(exports2, module2) {
|
|
"use strict";
|
|
var EventEmitter = require("events");
|
|
var https = require("https");
|
|
var http = require("http");
|
|
var net = require("net");
|
|
var tls = require("tls");
|
|
var { randomBytes, createHash } = require("crypto");
|
|
var { Duplex, Readable } = require("stream");
|
|
var { URL } = require("url");
|
|
var PerMessageDeflate = require_permessage_deflate();
|
|
var Receiver2 = require_receiver();
|
|
var Sender2 = require_sender();
|
|
var { isBlob } = require_validation();
|
|
var {
|
|
BINARY_TYPES,
|
|
CLOSE_TIMEOUT,
|
|
EMPTY_BUFFER,
|
|
GUID,
|
|
kForOnEventAttribute,
|
|
kListener,
|
|
kStatusCode,
|
|
kWebSocket,
|
|
NOOP
|
|
} = require_constants();
|
|
var {
|
|
EventTarget: { addEventListener, removeEventListener }
|
|
} = require_event_target();
|
|
var { format, parse: parse2 } = require_extension();
|
|
var { toBuffer } = require_buffer_util();
|
|
var kAborted = /* @__PURE__ */ Symbol("kAborted");
|
|
var protocolVersions = [8, 13];
|
|
var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
|
|
var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
|
|
var WebSocket2 = class _WebSocket extends EventEmitter {
|
|
/**
|
|
* Create a new `WebSocket`.
|
|
*
|
|
* @param {(String|URL)} address The URL to which to connect
|
|
* @param {(String|String[])} [protocols] The subprotocols
|
|
* @param {Object} [options] Connection options
|
|
*/
|
|
constructor(address, protocols, options2) {
|
|
super();
|
|
this._binaryType = BINARY_TYPES[0];
|
|
this._closeCode = 1006;
|
|
this._closeFrameReceived = false;
|
|
this._closeFrameSent = false;
|
|
this._closeMessage = EMPTY_BUFFER;
|
|
this._closeTimer = null;
|
|
this._errorEmitted = false;
|
|
this._extensions = {};
|
|
this._paused = false;
|
|
this._protocol = "";
|
|
this._readyState = _WebSocket.CONNECTING;
|
|
this._receiver = null;
|
|
this._sender = null;
|
|
this._socket = null;
|
|
if (address !== null) {
|
|
this._bufferedAmount = 0;
|
|
this._isServer = false;
|
|
this._redirects = 0;
|
|
if (protocols === void 0) {
|
|
protocols = [];
|
|
} else if (!Array.isArray(protocols)) {
|
|
if (typeof protocols === "object" && protocols !== null) {
|
|
options2 = protocols;
|
|
protocols = [];
|
|
} else {
|
|
protocols = [protocols];
|
|
}
|
|
}
|
|
initAsClient(this, address, protocols, options2);
|
|
} else {
|
|
this._autoPong = options2.autoPong;
|
|
this._closeTimeout = options2.closeTimeout;
|
|
this._isServer = true;
|
|
}
|
|
}
|
|
/**
|
|
* For historical reasons, the custom "nodebuffer" type is used by the default
|
|
* instead of "blob".
|
|
*
|
|
* @type {String}
|
|
*/
|
|
get binaryType() {
|
|
return this._binaryType;
|
|
}
|
|
set binaryType(type) {
|
|
if (!BINARY_TYPES.includes(type)) return;
|
|
this._binaryType = type;
|
|
if (this._receiver) this._receiver._binaryType = type;
|
|
}
|
|
/**
|
|
* @type {Number}
|
|
*/
|
|
get bufferedAmount() {
|
|
if (!this._socket) return this._bufferedAmount;
|
|
return this._socket._writableState.length + this._sender._bufferedBytes;
|
|
}
|
|
/**
|
|
* @type {String}
|
|
*/
|
|
get extensions() {
|
|
return Object.keys(this._extensions).join();
|
|
}
|
|
/**
|
|
* @type {Boolean}
|
|
*/
|
|
get isPaused() {
|
|
return this._paused;
|
|
}
|
|
/**
|
|
* @type {Function}
|
|
*/
|
|
/* istanbul ignore next */
|
|
get onclose() {
|
|
return null;
|
|
}
|
|
/**
|
|
* @type {Function}
|
|
*/
|
|
/* istanbul ignore next */
|
|
get onerror() {
|
|
return null;
|
|
}
|
|
/**
|
|
* @type {Function}
|
|
*/
|
|
/* istanbul ignore next */
|
|
get onopen() {
|
|
return null;
|
|
}
|
|
/**
|
|
* @type {Function}
|
|
*/
|
|
/* istanbul ignore next */
|
|
get onmessage() {
|
|
return null;
|
|
}
|
|
/**
|
|
* @type {String}
|
|
*/
|
|
get protocol() {
|
|
return this._protocol;
|
|
}
|
|
/**
|
|
* @type {Number}
|
|
*/
|
|
get readyState() {
|
|
return this._readyState;
|
|
}
|
|
/**
|
|
* @type {String}
|
|
*/
|
|
get url() {
|
|
return this._url;
|
|
}
|
|
/**
|
|
* Set up the socket and the internal resources.
|
|
*
|
|
* @param {Duplex} socket The network socket between the server and client
|
|
* @param {Buffer} head The first packet of the upgraded stream
|
|
* @param {Object} options Options object
|
|
* @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
|
|
* any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
|
|
* multiple times in the same tick
|
|
* @param {Function} [options.generateMask] The function used to generate the
|
|
* masking key
|
|
* @param {Number} [options.maxPayload=0] The maximum allowed message size
|
|
* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
|
|
* not to skip UTF-8 validation for text and close messages
|
|
* @private
|
|
*/
|
|
setSocket(socket, head, options2) {
|
|
const receiver = new Receiver2({
|
|
allowSynchronousEvents: options2.allowSynchronousEvents,
|
|
binaryType: this.binaryType,
|
|
extensions: this._extensions,
|
|
isServer: this._isServer,
|
|
maxPayload: options2.maxPayload,
|
|
skipUTF8Validation: options2.skipUTF8Validation
|
|
});
|
|
const sender = new Sender2(socket, this._extensions, options2.generateMask);
|
|
this._receiver = receiver;
|
|
this._sender = sender;
|
|
this._socket = socket;
|
|
receiver[kWebSocket] = this;
|
|
sender[kWebSocket] = this;
|
|
socket[kWebSocket] = this;
|
|
receiver.on("conclude", receiverOnConclude);
|
|
receiver.on("drain", receiverOnDrain);
|
|
receiver.on("error", receiverOnError);
|
|
receiver.on("message", receiverOnMessage);
|
|
receiver.on("ping", receiverOnPing);
|
|
receiver.on("pong", receiverOnPong);
|
|
sender.onerror = senderOnError;
|
|
if (socket.setTimeout) socket.setTimeout(0);
|
|
if (socket.setNoDelay) socket.setNoDelay();
|
|
if (head.length > 0) socket.unshift(head);
|
|
socket.on("close", socketOnClose);
|
|
socket.on("data", socketOnData);
|
|
socket.on("end", socketOnEnd);
|
|
socket.on("error", socketOnError);
|
|
this._readyState = _WebSocket.OPEN;
|
|
this.emit("open");
|
|
}
|
|
/**
|
|
* Emit the `'close'` event.
|
|
*
|
|
* @private
|
|
*/
|
|
emitClose() {
|
|
if (!this._socket) {
|
|
this._readyState = _WebSocket.CLOSED;
|
|
this.emit("close", this._closeCode, this._closeMessage);
|
|
return;
|
|
}
|
|
if (this._extensions[PerMessageDeflate.extensionName]) {
|
|
this._extensions[PerMessageDeflate.extensionName].cleanup();
|
|
}
|
|
this._receiver.removeAllListeners();
|
|
this._readyState = _WebSocket.CLOSED;
|
|
this.emit("close", this._closeCode, this._closeMessage);
|
|
}
|
|
/**
|
|
* Start a closing handshake.
|
|
*
|
|
* +----------+ +-----------+ +----------+
|
|
* - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
|
|
* | +----------+ +-----------+ +----------+ |
|
|
* +----------+ +-----------+ |
|
|
* CLOSING |ws.close()|<--|close frame|<--+-----+ CLOSING
|
|
* +----------+ +-----------+ |
|
|
* | | | +---+ |
|
|
* +------------------------+-->|fin| - - - -
|
|
* | +---+ | +---+
|
|
* - - - - -|fin|<---------------------+
|
|
* +---+
|
|
*
|
|
* @param {Number} [code] Status code explaining why the connection is closing
|
|
* @param {(String|Buffer)} [data] The reason why the connection is
|
|
* closing
|
|
* @public
|
|
*/
|
|
close(code, data) {
|
|
if (this.readyState === _WebSocket.CLOSED) return;
|
|
if (this.readyState === _WebSocket.CONNECTING) {
|
|
const msg = "WebSocket was closed before the connection was established";
|
|
abortHandshake(this, this._req, msg);
|
|
return;
|
|
}
|
|
if (this.readyState === _WebSocket.CLOSING) {
|
|
if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
|
|
this._socket.end();
|
|
}
|
|
return;
|
|
}
|
|
this._readyState = _WebSocket.CLOSING;
|
|
this._sender.close(code, data, !this._isServer, (err) => {
|
|
if (err) return;
|
|
this._closeFrameSent = true;
|
|
if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
|
|
this._socket.end();
|
|
}
|
|
});
|
|
setCloseTimer(this);
|
|
}
|
|
/**
|
|
* Pause the socket.
|
|
*
|
|
* @public
|
|
*/
|
|
pause() {
|
|
if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
|
|
return;
|
|
}
|
|
this._paused = true;
|
|
this._socket.pause();
|
|
}
|
|
/**
|
|
* Send a ping.
|
|
*
|
|
* @param {*} [data] The data to send
|
|
* @param {Boolean} [mask] Indicates whether or not to mask `data`
|
|
* @param {Function} [cb] Callback which is executed when the ping is sent
|
|
* @public
|
|
*/
|
|
ping(data, mask, cb) {
|
|
if (this.readyState === _WebSocket.CONNECTING) {
|
|
throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
|
|
}
|
|
if (typeof data === "function") {
|
|
cb = data;
|
|
data = mask = void 0;
|
|
} else if (typeof mask === "function") {
|
|
cb = mask;
|
|
mask = void 0;
|
|
}
|
|
if (typeof data === "number") data = data.toString();
|
|
if (this.readyState !== _WebSocket.OPEN) {
|
|
sendAfterClose(this, data, cb);
|
|
return;
|
|
}
|
|
if (mask === void 0) mask = !this._isServer;
|
|
this._sender.ping(data || EMPTY_BUFFER, mask, cb);
|
|
}
|
|
/**
|
|
* Send a pong.
|
|
*
|
|
* @param {*} [data] The data to send
|
|
* @param {Boolean} [mask] Indicates whether or not to mask `data`
|
|
* @param {Function} [cb] Callback which is executed when the pong is sent
|
|
* @public
|
|
*/
|
|
pong(data, mask, cb) {
|
|
if (this.readyState === _WebSocket.CONNECTING) {
|
|
throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
|
|
}
|
|
if (typeof data === "function") {
|
|
cb = data;
|
|
data = mask = void 0;
|
|
} else if (typeof mask === "function") {
|
|
cb = mask;
|
|
mask = void 0;
|
|
}
|
|
if (typeof data === "number") data = data.toString();
|
|
if (this.readyState !== _WebSocket.OPEN) {
|
|
sendAfterClose(this, data, cb);
|
|
return;
|
|
}
|
|
if (mask === void 0) mask = !this._isServer;
|
|
this._sender.pong(data || EMPTY_BUFFER, mask, cb);
|
|
}
|
|
/**
|
|
* Resume the socket.
|
|
*
|
|
* @public
|
|
*/
|
|
resume() {
|
|
if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
|
|
return;
|
|
}
|
|
this._paused = false;
|
|
if (!this._receiver._writableState.needDrain) this._socket.resume();
|
|
}
|
|
/**
|
|
* Send a data message.
|
|
*
|
|
* @param {*} data The message to send
|
|
* @param {Object} [options] Options object
|
|
* @param {Boolean} [options.binary] Specifies whether `data` is binary or
|
|
* text
|
|
* @param {Boolean} [options.compress] Specifies whether or not to compress
|
|
* `data`
|
|
* @param {Boolean} [options.fin=true] Specifies whether the fragment is the
|
|
* last one
|
|
* @param {Boolean} [options.mask] Specifies whether or not to mask `data`
|
|
* @param {Function} [cb] Callback which is executed when data is written out
|
|
* @public
|
|
*/
|
|
send(data, options2, cb) {
|
|
if (this.readyState === _WebSocket.CONNECTING) {
|
|
throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
|
|
}
|
|
if (typeof options2 === "function") {
|
|
cb = options2;
|
|
options2 = {};
|
|
}
|
|
if (typeof data === "number") data = data.toString();
|
|
if (this.readyState !== _WebSocket.OPEN) {
|
|
sendAfterClose(this, data, cb);
|
|
return;
|
|
}
|
|
const opts = {
|
|
binary: typeof data !== "string",
|
|
mask: !this._isServer,
|
|
compress: true,
|
|
fin: true,
|
|
...options2
|
|
};
|
|
if (!this._extensions[PerMessageDeflate.extensionName]) {
|
|
opts.compress = false;
|
|
}
|
|
this._sender.send(data || EMPTY_BUFFER, opts, cb);
|
|
}
|
|
/**
|
|
* Forcibly close the connection.
|
|
*
|
|
* @public
|
|
*/
|
|
terminate() {
|
|
if (this.readyState === _WebSocket.CLOSED) return;
|
|
if (this.readyState === _WebSocket.CONNECTING) {
|
|
const msg = "WebSocket was closed before the connection was established";
|
|
abortHandshake(this, this._req, msg);
|
|
return;
|
|
}
|
|
if (this._socket) {
|
|
this._readyState = _WebSocket.CLOSING;
|
|
this._socket.destroy();
|
|
}
|
|
}
|
|
};
|
|
Object.defineProperty(WebSocket2, "CONNECTING", {
|
|
enumerable: true,
|
|
value: readyStates.indexOf("CONNECTING")
|
|
});
|
|
Object.defineProperty(WebSocket2.prototype, "CONNECTING", {
|
|
enumerable: true,
|
|
value: readyStates.indexOf("CONNECTING")
|
|
});
|
|
Object.defineProperty(WebSocket2, "OPEN", {
|
|
enumerable: true,
|
|
value: readyStates.indexOf("OPEN")
|
|
});
|
|
Object.defineProperty(WebSocket2.prototype, "OPEN", {
|
|
enumerable: true,
|
|
value: readyStates.indexOf("OPEN")
|
|
});
|
|
Object.defineProperty(WebSocket2, "CLOSING", {
|
|
enumerable: true,
|
|
value: readyStates.indexOf("CLOSING")
|
|
});
|
|
Object.defineProperty(WebSocket2.prototype, "CLOSING", {
|
|
enumerable: true,
|
|
value: readyStates.indexOf("CLOSING")
|
|
});
|
|
Object.defineProperty(WebSocket2, "CLOSED", {
|
|
enumerable: true,
|
|
value: readyStates.indexOf("CLOSED")
|
|
});
|
|
Object.defineProperty(WebSocket2.prototype, "CLOSED", {
|
|
enumerable: true,
|
|
value: readyStates.indexOf("CLOSED")
|
|
});
|
|
[
|
|
"binaryType",
|
|
"bufferedAmount",
|
|
"extensions",
|
|
"isPaused",
|
|
"protocol",
|
|
"readyState",
|
|
"url"
|
|
].forEach((property) => {
|
|
Object.defineProperty(WebSocket2.prototype, property, { enumerable: true });
|
|
});
|
|
["open", "error", "close", "message"].forEach((method) => {
|
|
Object.defineProperty(WebSocket2.prototype, `on${method}`, {
|
|
enumerable: true,
|
|
get() {
|
|
for (const listener of this.listeners(method)) {
|
|
if (listener[kForOnEventAttribute]) return listener[kListener];
|
|
}
|
|
return null;
|
|
},
|
|
set(handler) {
|
|
for (const listener of this.listeners(method)) {
|
|
if (listener[kForOnEventAttribute]) {
|
|
this.removeListener(method, listener);
|
|
break;
|
|
}
|
|
}
|
|
if (typeof handler !== "function") return;
|
|
this.addEventListener(method, handler, {
|
|
[kForOnEventAttribute]: true
|
|
});
|
|
}
|
|
});
|
|
});
|
|
WebSocket2.prototype.addEventListener = addEventListener;
|
|
WebSocket2.prototype.removeEventListener = removeEventListener;
|
|
module2.exports = WebSocket2;
|
|
function initAsClient(websocket, address, protocols, options2) {
|
|
const opts = {
|
|
allowSynchronousEvents: true,
|
|
autoPong: true,
|
|
closeTimeout: CLOSE_TIMEOUT,
|
|
protocolVersion: protocolVersions[1],
|
|
maxPayload: 100 * 1024 * 1024,
|
|
skipUTF8Validation: false,
|
|
perMessageDeflate: true,
|
|
followRedirects: false,
|
|
maxRedirects: 10,
|
|
...options2,
|
|
socketPath: void 0,
|
|
hostname: void 0,
|
|
protocol: void 0,
|
|
timeout: void 0,
|
|
method: "GET",
|
|
host: void 0,
|
|
path: void 0,
|
|
port: void 0
|
|
};
|
|
websocket._autoPong = opts.autoPong;
|
|
websocket._closeTimeout = opts.closeTimeout;
|
|
if (!protocolVersions.includes(opts.protocolVersion)) {
|
|
throw new RangeError(
|
|
`Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
|
|
);
|
|
}
|
|
let parsedUrl;
|
|
if (address instanceof URL) {
|
|
parsedUrl = address;
|
|
} else {
|
|
try {
|
|
parsedUrl = new URL(address);
|
|
} catch (e) {
|
|
throw new SyntaxError(`Invalid URL: ${address}`);
|
|
}
|
|
}
|
|
if (parsedUrl.protocol === "http:") {
|
|
parsedUrl.protocol = "ws:";
|
|
} else if (parsedUrl.protocol === "https:") {
|
|
parsedUrl.protocol = "wss:";
|
|
}
|
|
websocket._url = parsedUrl.href;
|
|
const isSecure = parsedUrl.protocol === "wss:";
|
|
const isIpcUrl = parsedUrl.protocol === "ws+unix:";
|
|
let invalidUrlMessage;
|
|
if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
|
|
invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https:", or "ws+unix:"`;
|
|
} else if (isIpcUrl && !parsedUrl.pathname) {
|
|
invalidUrlMessage = "The URL's pathname is empty";
|
|
} else if (parsedUrl.hash) {
|
|
invalidUrlMessage = "The URL contains a fragment identifier";
|
|
}
|
|
if (invalidUrlMessage) {
|
|
const err = new SyntaxError(invalidUrlMessage);
|
|
if (websocket._redirects === 0) {
|
|
throw err;
|
|
} else {
|
|
emitErrorAndClose(websocket, err);
|
|
return;
|
|
}
|
|
}
|
|
const defaultPort = isSecure ? 443 : 80;
|
|
const key = randomBytes(16).toString("base64");
|
|
const request = isSecure ? https.request : http.request;
|
|
const protocolSet = /* @__PURE__ */ new Set();
|
|
let perMessageDeflate;
|
|
opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
|
|
opts.defaultPort = opts.defaultPort || defaultPort;
|
|
opts.port = parsedUrl.port || defaultPort;
|
|
opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
|
|
opts.headers = {
|
|
...opts.headers,
|
|
"Sec-WebSocket-Version": opts.protocolVersion,
|
|
"Sec-WebSocket-Key": key,
|
|
Connection: "Upgrade",
|
|
Upgrade: "websocket"
|
|
};
|
|
opts.path = parsedUrl.pathname + parsedUrl.search;
|
|
opts.timeout = opts.handshakeTimeout;
|
|
if (opts.perMessageDeflate) {
|
|
perMessageDeflate = new PerMessageDeflate(
|
|
opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
|
|
false,
|
|
opts.maxPayload
|
|
);
|
|
opts.headers["Sec-WebSocket-Extensions"] = format({
|
|
[PerMessageDeflate.extensionName]: perMessageDeflate.offer()
|
|
});
|
|
}
|
|
if (protocols.length) {
|
|
for (const protocol of protocols) {
|
|
if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) {
|
|
throw new SyntaxError(
|
|
"An invalid or duplicated subprotocol was specified"
|
|
);
|
|
}
|
|
protocolSet.add(protocol);
|
|
}
|
|
opts.headers["Sec-WebSocket-Protocol"] = protocols.join(",");
|
|
}
|
|
if (opts.origin) {
|
|
if (opts.protocolVersion < 13) {
|
|
opts.headers["Sec-WebSocket-Origin"] = opts.origin;
|
|
} else {
|
|
opts.headers.Origin = opts.origin;
|
|
}
|
|
}
|
|
if (parsedUrl.username || parsedUrl.password) {
|
|
opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
|
|
}
|
|
if (isIpcUrl) {
|
|
const parts = opts.path.split(":");
|
|
opts.socketPath = parts[0];
|
|
opts.path = parts[1];
|
|
}
|
|
let req;
|
|
if (opts.followRedirects) {
|
|
if (websocket._redirects === 0) {
|
|
websocket._originalIpc = isIpcUrl;
|
|
websocket._originalSecure = isSecure;
|
|
websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host;
|
|
const headers = options2 && options2.headers;
|
|
options2 = { ...options2, headers: {} };
|
|
if (headers) {
|
|
for (const [key2, value] of Object.entries(headers)) {
|
|
options2.headers[key2.toLowerCase()] = value;
|
|
}
|
|
}
|
|
} else if (websocket.listenerCount("redirect") === 0) {
|
|
const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
|
|
if (!isSameHost || websocket._originalSecure && !isSecure) {
|
|
delete opts.headers.authorization;
|
|
delete opts.headers.cookie;
|
|
if (!isSameHost) delete opts.headers.host;
|
|
opts.auth = void 0;
|
|
}
|
|
}
|
|
if (opts.auth && !options2.headers.authorization) {
|
|
options2.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
|
|
}
|
|
req = websocket._req = request(opts);
|
|
if (websocket._redirects) {
|
|
websocket.emit("redirect", websocket.url, req);
|
|
}
|
|
} else {
|
|
req = websocket._req = request(opts);
|
|
}
|
|
if (opts.timeout) {
|
|
req.on("timeout", () => {
|
|
abortHandshake(websocket, req, "Opening handshake has timed out");
|
|
});
|
|
}
|
|
req.on("error", (err) => {
|
|
if (req === null || req[kAborted]) return;
|
|
req = websocket._req = null;
|
|
emitErrorAndClose(websocket, err);
|
|
});
|
|
req.on("response", (res) => {
|
|
const location = res.headers.location;
|
|
const statusCode = res.statusCode;
|
|
if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
|
|
if (++websocket._redirects > opts.maxRedirects) {
|
|
abortHandshake(websocket, req, "Maximum redirects exceeded");
|
|
return;
|
|
}
|
|
req.abort();
|
|
let addr;
|
|
try {
|
|
addr = new URL(location, address);
|
|
} catch (e) {
|
|
const err = new SyntaxError(`Invalid URL: ${location}`);
|
|
emitErrorAndClose(websocket, err);
|
|
return;
|
|
}
|
|
initAsClient(websocket, addr, protocols, options2);
|
|
} else if (!websocket.emit("unexpected-response", req, res)) {
|
|
abortHandshake(
|
|
websocket,
|
|
req,
|
|
`Unexpected server response: ${res.statusCode}`
|
|
);
|
|
}
|
|
});
|
|
req.on("upgrade", (res, socket, head) => {
|
|
websocket.emit("upgrade", res);
|
|
if (websocket.readyState !== WebSocket2.CONNECTING) return;
|
|
req = websocket._req = null;
|
|
const upgrade = res.headers.upgrade;
|
|
if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
|
|
abortHandshake(websocket, socket, "Invalid Upgrade header");
|
|
return;
|
|
}
|
|
const digest = createHash("sha1").update(key + GUID).digest("base64");
|
|
if (res.headers["sec-websocket-accept"] !== digest) {
|
|
abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
|
|
return;
|
|
}
|
|
const serverProt = res.headers["sec-websocket-protocol"];
|
|
let protError;
|
|
if (serverProt !== void 0) {
|
|
if (!protocolSet.size) {
|
|
protError = "Server sent a subprotocol but none was requested";
|
|
} else if (!protocolSet.has(serverProt)) {
|
|
protError = "Server sent an invalid subprotocol";
|
|
}
|
|
} else if (protocolSet.size) {
|
|
protError = "Server sent no subprotocol";
|
|
}
|
|
if (protError) {
|
|
abortHandshake(websocket, socket, protError);
|
|
return;
|
|
}
|
|
if (serverProt) websocket._protocol = serverProt;
|
|
const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
|
|
if (secWebSocketExtensions !== void 0) {
|
|
if (!perMessageDeflate) {
|
|
const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested";
|
|
abortHandshake(websocket, socket, message);
|
|
return;
|
|
}
|
|
let extensions;
|
|
try {
|
|
extensions = parse2(secWebSocketExtensions);
|
|
} catch (err) {
|
|
const message = "Invalid Sec-WebSocket-Extensions header";
|
|
abortHandshake(websocket, socket, message);
|
|
return;
|
|
}
|
|
const extensionNames = Object.keys(extensions);
|
|
if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
|
|
const message = "Server indicated an extension that was not requested";
|
|
abortHandshake(websocket, socket, message);
|
|
return;
|
|
}
|
|
try {
|
|
perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
|
|
} catch (err) {
|
|
const message = "Invalid Sec-WebSocket-Extensions header";
|
|
abortHandshake(websocket, socket, message);
|
|
return;
|
|
}
|
|
websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
|
|
}
|
|
websocket.setSocket(socket, head, {
|
|
allowSynchronousEvents: opts.allowSynchronousEvents,
|
|
generateMask: opts.generateMask,
|
|
maxPayload: opts.maxPayload,
|
|
skipUTF8Validation: opts.skipUTF8Validation
|
|
});
|
|
});
|
|
if (opts.finishRequest) {
|
|
opts.finishRequest(req, websocket);
|
|
} else {
|
|
req.end();
|
|
}
|
|
}
|
|
function emitErrorAndClose(websocket, err) {
|
|
websocket._readyState = WebSocket2.CLOSING;
|
|
websocket._errorEmitted = true;
|
|
websocket.emit("error", err);
|
|
websocket.emitClose();
|
|
}
|
|
function netConnect(options2) {
|
|
options2.path = options2.socketPath;
|
|
return net.connect(options2);
|
|
}
|
|
function tlsConnect(options2) {
|
|
options2.path = void 0;
|
|
if (!options2.servername && options2.servername !== "") {
|
|
options2.servername = net.isIP(options2.host) ? "" : options2.host;
|
|
}
|
|
return tls.connect(options2);
|
|
}
|
|
function abortHandshake(websocket, stream, message) {
|
|
websocket._readyState = WebSocket2.CLOSING;
|
|
const err = new Error(message);
|
|
Error.captureStackTrace(err, abortHandshake);
|
|
if (stream.setHeader) {
|
|
stream[kAborted] = true;
|
|
stream.abort();
|
|
if (stream.socket && !stream.socket.destroyed) {
|
|
stream.socket.destroy();
|
|
}
|
|
process.nextTick(emitErrorAndClose, websocket, err);
|
|
} else {
|
|
stream.destroy(err);
|
|
stream.once("error", websocket.emit.bind(websocket, "error"));
|
|
stream.once("close", websocket.emitClose.bind(websocket));
|
|
}
|
|
}
|
|
function sendAfterClose(websocket, data, cb) {
|
|
if (data) {
|
|
const length = isBlob(data) ? data.size : toBuffer(data).length;
|
|
if (websocket._socket) websocket._sender._bufferedBytes += length;
|
|
else websocket._bufferedAmount += length;
|
|
}
|
|
if (cb) {
|
|
const err = new Error(
|
|
`WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`
|
|
);
|
|
process.nextTick(cb, err);
|
|
}
|
|
}
|
|
function receiverOnConclude(code, reason) {
|
|
const websocket = this[kWebSocket];
|
|
websocket._closeFrameReceived = true;
|
|
websocket._closeMessage = reason;
|
|
websocket._closeCode = code;
|
|
if (websocket._socket[kWebSocket] === void 0) return;
|
|
websocket._socket.removeListener("data", socketOnData);
|
|
process.nextTick(resume, websocket._socket);
|
|
if (code === 1005) websocket.close();
|
|
else websocket.close(code, reason);
|
|
}
|
|
function receiverOnDrain() {
|
|
const websocket = this[kWebSocket];
|
|
if (!websocket.isPaused) websocket._socket.resume();
|
|
}
|
|
function receiverOnError(err) {
|
|
const websocket = this[kWebSocket];
|
|
if (websocket._socket[kWebSocket] !== void 0) {
|
|
websocket._socket.removeListener("data", socketOnData);
|
|
process.nextTick(resume, websocket._socket);
|
|
websocket.close(err[kStatusCode]);
|
|
}
|
|
if (!websocket._errorEmitted) {
|
|
websocket._errorEmitted = true;
|
|
websocket.emit("error", err);
|
|
}
|
|
}
|
|
function receiverOnFinish() {
|
|
this[kWebSocket].emitClose();
|
|
}
|
|
function receiverOnMessage(data, isBinary) {
|
|
this[kWebSocket].emit("message", data, isBinary);
|
|
}
|
|
function receiverOnPing(data) {
|
|
const websocket = this[kWebSocket];
|
|
if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
|
|
websocket.emit("ping", data);
|
|
}
|
|
function receiverOnPong(data) {
|
|
this[kWebSocket].emit("pong", data);
|
|
}
|
|
function resume(stream) {
|
|
stream.resume();
|
|
}
|
|
function senderOnError(err) {
|
|
const websocket = this[kWebSocket];
|
|
if (websocket.readyState === WebSocket2.CLOSED) return;
|
|
if (websocket.readyState === WebSocket2.OPEN) {
|
|
websocket._readyState = WebSocket2.CLOSING;
|
|
setCloseTimer(websocket);
|
|
}
|
|
this._socket.end();
|
|
if (!websocket._errorEmitted) {
|
|
websocket._errorEmitted = true;
|
|
websocket.emit("error", err);
|
|
}
|
|
}
|
|
function setCloseTimer(websocket) {
|
|
websocket._closeTimer = setTimeout(
|
|
websocket._socket.destroy.bind(websocket._socket),
|
|
websocket._closeTimeout
|
|
);
|
|
}
|
|
function socketOnClose() {
|
|
const websocket = this[kWebSocket];
|
|
this.removeListener("close", socketOnClose);
|
|
this.removeListener("data", socketOnData);
|
|
this.removeListener("end", socketOnEnd);
|
|
websocket._readyState = WebSocket2.CLOSING;
|
|
if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && this._readableState.length !== 0) {
|
|
const chunk = this.read(this._readableState.length);
|
|
websocket._receiver.write(chunk);
|
|
}
|
|
websocket._receiver.end();
|
|
this[kWebSocket] = void 0;
|
|
clearTimeout(websocket._closeTimer);
|
|
if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) {
|
|
websocket.emitClose();
|
|
} else {
|
|
websocket._receiver.on("error", receiverOnFinish);
|
|
websocket._receiver.on("finish", receiverOnFinish);
|
|
}
|
|
}
|
|
function socketOnData(chunk) {
|
|
if (!this[kWebSocket]._receiver.write(chunk)) {
|
|
this.pause();
|
|
}
|
|
}
|
|
function socketOnEnd() {
|
|
const websocket = this[kWebSocket];
|
|
websocket._readyState = WebSocket2.CLOSING;
|
|
websocket._receiver.end();
|
|
this.end();
|
|
}
|
|
function socketOnError() {
|
|
const websocket = this[kWebSocket];
|
|
this.removeListener("error", socketOnError);
|
|
this.on("error", NOOP);
|
|
if (websocket) {
|
|
websocket._readyState = WebSocket2.CLOSING;
|
|
this.destroy();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/stream.js
|
|
var require_stream = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/stream.js"(exports2, module2) {
|
|
"use strict";
|
|
var WebSocket2 = require_websocket();
|
|
var { Duplex } = require("stream");
|
|
function emitClose(stream) {
|
|
stream.emit("close");
|
|
}
|
|
function duplexOnEnd() {
|
|
if (!this.destroyed && this._writableState.finished) {
|
|
this.destroy();
|
|
}
|
|
}
|
|
function duplexOnError(err) {
|
|
this.removeListener("error", duplexOnError);
|
|
this.destroy();
|
|
if (this.listenerCount("error") === 0) {
|
|
this.emit("error", err);
|
|
}
|
|
}
|
|
function createWebSocketStream2(ws, options2) {
|
|
let terminateOnDestroy = true;
|
|
const duplex = new Duplex({
|
|
...options2,
|
|
autoDestroy: false,
|
|
emitClose: false,
|
|
objectMode: false,
|
|
writableObjectMode: false
|
|
});
|
|
ws.on("message", function message(msg, isBinary) {
|
|
const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
|
|
if (!duplex.push(data)) ws.pause();
|
|
});
|
|
ws.once("error", function error(err) {
|
|
if (duplex.destroyed) return;
|
|
terminateOnDestroy = false;
|
|
duplex.destroy(err);
|
|
});
|
|
ws.once("close", function close() {
|
|
if (duplex.destroyed) return;
|
|
duplex.push(null);
|
|
});
|
|
duplex._destroy = function(err, callback) {
|
|
if (ws.readyState === ws.CLOSED) {
|
|
callback(err);
|
|
process.nextTick(emitClose, duplex);
|
|
return;
|
|
}
|
|
let called = false;
|
|
ws.once("error", function error(err2) {
|
|
called = true;
|
|
callback(err2);
|
|
});
|
|
ws.once("close", function close() {
|
|
if (!called) callback(err);
|
|
process.nextTick(emitClose, duplex);
|
|
});
|
|
if (terminateOnDestroy) ws.terminate();
|
|
};
|
|
duplex._final = function(callback) {
|
|
if (ws.readyState === ws.CONNECTING) {
|
|
ws.once("open", function open() {
|
|
duplex._final(callback);
|
|
});
|
|
return;
|
|
}
|
|
if (ws._socket === null) return;
|
|
if (ws._socket._writableState.finished) {
|
|
callback();
|
|
if (duplex._readableState.endEmitted) duplex.destroy();
|
|
} else {
|
|
ws._socket.once("finish", function finish() {
|
|
callback();
|
|
});
|
|
ws.close();
|
|
}
|
|
};
|
|
duplex._read = function() {
|
|
if (ws.isPaused) ws.resume();
|
|
};
|
|
duplex._write = function(chunk, encoding, callback) {
|
|
if (ws.readyState === ws.CONNECTING) {
|
|
ws.once("open", function open() {
|
|
duplex._write(chunk, encoding, callback);
|
|
});
|
|
return;
|
|
}
|
|
ws.send(chunk, callback);
|
|
};
|
|
duplex.on("end", duplexOnEnd);
|
|
duplex.on("error", duplexOnError);
|
|
return duplex;
|
|
}
|
|
module2.exports = createWebSocketStream2;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/subprotocol.js
|
|
var require_subprotocol = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/subprotocol.js"(exports2, module2) {
|
|
"use strict";
|
|
var { tokenChars } = require_validation();
|
|
function parse2(header) {
|
|
const protocols = /* @__PURE__ */ new Set();
|
|
let start = -1;
|
|
let end = -1;
|
|
let i = 0;
|
|
for (i; i < header.length; i++) {
|
|
const code = header.charCodeAt(i);
|
|
if (end === -1 && tokenChars[code] === 1) {
|
|
if (start === -1) start = i;
|
|
} else if (i !== 0 && (code === 32 || code === 9)) {
|
|
if (end === -1 && start !== -1) end = i;
|
|
} else if (code === 44) {
|
|
if (start === -1) {
|
|
throw new SyntaxError(`Unexpected character at index ${i}`);
|
|
}
|
|
if (end === -1) end = i;
|
|
const protocol2 = header.slice(start, end);
|
|
if (protocols.has(protocol2)) {
|
|
throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`);
|
|
}
|
|
protocols.add(protocol2);
|
|
start = end = -1;
|
|
} else {
|
|
throw new SyntaxError(`Unexpected character at index ${i}`);
|
|
}
|
|
}
|
|
if (start === -1 || end !== -1) {
|
|
throw new SyntaxError("Unexpected end of input");
|
|
}
|
|
const protocol = header.slice(start, i);
|
|
if (protocols.has(protocol)) {
|
|
throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
|
|
}
|
|
protocols.add(protocol);
|
|
return protocols;
|
|
}
|
|
module2.exports = { parse: parse2 };
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket-server.js
|
|
var require_websocket_server = __commonJS({
|
|
"node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket-server.js"(exports2, module2) {
|
|
"use strict";
|
|
var EventEmitter = require("events");
|
|
var http = require("http");
|
|
var { Duplex } = require("stream");
|
|
var { createHash } = require("crypto");
|
|
var extension = require_extension();
|
|
var PerMessageDeflate = require_permessage_deflate();
|
|
var subprotocol = require_subprotocol();
|
|
var WebSocket2 = require_websocket();
|
|
var { CLOSE_TIMEOUT, GUID, kWebSocket } = require_constants();
|
|
var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
|
|
var RUNNING = 0;
|
|
var CLOSING = 1;
|
|
var CLOSED = 2;
|
|
var WebSocketServer2 = class extends EventEmitter {
|
|
/**
|
|
* Create a `WebSocketServer` instance.
|
|
*
|
|
* @param {Object} options Configuration options
|
|
* @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
|
|
* any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
|
|
* multiple times in the same tick
|
|
* @param {Boolean} [options.autoPong=true] Specifies whether or not to
|
|
* automatically send a pong in response to a ping
|
|
* @param {Number} [options.backlog=511] The maximum length of the queue of
|
|
* pending connections
|
|
* @param {Boolean} [options.clientTracking=true] Specifies whether or not to
|
|
* track clients
|
|
* @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
|
|
* wait for the closing handshake to finish after `websocket.close()` is
|
|
* called
|
|
* @param {Function} [options.handleProtocols] A hook to handle protocols
|
|
* @param {String} [options.host] The hostname where to bind the server
|
|
* @param {Number} [options.maxPayload=104857600] The maximum allowed message
|
|
* size
|
|
* @param {Boolean} [options.noServer=false] Enable no server mode
|
|
* @param {String} [options.path] Accept only connections matching this path
|
|
* @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
|
|
* permessage-deflate
|
|
* @param {Number} [options.port] The port where to bind the server
|
|
* @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
|
|
* server to use
|
|
* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
|
|
* not to skip UTF-8 validation for text and close messages
|
|
* @param {Function} [options.verifyClient] A hook to reject connections
|
|
* @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
|
|
* class to use. It must be the `WebSocket` class or class that extends it
|
|
* @param {Function} [callback] A listener for the `listening` event
|
|
*/
|
|
constructor(options2, callback) {
|
|
super();
|
|
options2 = {
|
|
allowSynchronousEvents: true,
|
|
autoPong: true,
|
|
maxPayload: 100 * 1024 * 1024,
|
|
skipUTF8Validation: false,
|
|
perMessageDeflate: false,
|
|
handleProtocols: null,
|
|
clientTracking: true,
|
|
closeTimeout: CLOSE_TIMEOUT,
|
|
verifyClient: null,
|
|
noServer: false,
|
|
backlog: null,
|
|
// use default (511 as implemented in net.js)
|
|
server: null,
|
|
host: null,
|
|
path: null,
|
|
port: null,
|
|
WebSocket: WebSocket2,
|
|
...options2
|
|
};
|
|
if (options2.port == null && !options2.server && !options2.noServer || options2.port != null && (options2.server || options2.noServer) || options2.server && options2.noServer) {
|
|
throw new TypeError(
|
|
'One and only one of the "port", "server", or "noServer" options must be specified'
|
|
);
|
|
}
|
|
if (options2.port != null) {
|
|
this._server = http.createServer((req, res) => {
|
|
const body = http.STATUS_CODES[426];
|
|
res.writeHead(426, {
|
|
"Content-Length": body.length,
|
|
"Content-Type": "text/plain"
|
|
});
|
|
res.end(body);
|
|
});
|
|
this._server.listen(
|
|
options2.port,
|
|
options2.host,
|
|
options2.backlog,
|
|
callback
|
|
);
|
|
} else if (options2.server) {
|
|
this._server = options2.server;
|
|
}
|
|
if (this._server) {
|
|
const emitConnection = this.emit.bind(this, "connection");
|
|
this._removeListeners = addListeners(this._server, {
|
|
listening: this.emit.bind(this, "listening"),
|
|
error: this.emit.bind(this, "error"),
|
|
upgrade: (req, socket, head) => {
|
|
this.handleUpgrade(req, socket, head, emitConnection);
|
|
}
|
|
});
|
|
}
|
|
if (options2.perMessageDeflate === true) options2.perMessageDeflate = {};
|
|
if (options2.clientTracking) {
|
|
this.clients = /* @__PURE__ */ new Set();
|
|
this._shouldEmitClose = false;
|
|
}
|
|
this.options = options2;
|
|
this._state = RUNNING;
|
|
}
|
|
/**
|
|
* Returns the bound address, the address family name, and port of the server
|
|
* as reported by the operating system if listening on an IP socket.
|
|
* If the server is listening on a pipe or UNIX domain socket, the name is
|
|
* returned as a string.
|
|
*
|
|
* @return {(Object|String|null)} The address of the server
|
|
* @public
|
|
*/
|
|
address() {
|
|
if (this.options.noServer) {
|
|
throw new Error('The server is operating in "noServer" mode');
|
|
}
|
|
if (!this._server) return null;
|
|
return this._server.address();
|
|
}
|
|
/**
|
|
* Stop the server from accepting new connections and emit the `'close'` event
|
|
* when all existing connections are closed.
|
|
*
|
|
* @param {Function} [cb] A one-time listener for the `'close'` event
|
|
* @public
|
|
*/
|
|
close(cb) {
|
|
if (this._state === CLOSED) {
|
|
if (cb) {
|
|
this.once("close", () => {
|
|
cb(new Error("The server is not running"));
|
|
});
|
|
}
|
|
process.nextTick(emitClose, this);
|
|
return;
|
|
}
|
|
if (cb) this.once("close", cb);
|
|
if (this._state === CLOSING) return;
|
|
this._state = CLOSING;
|
|
if (this.options.noServer || this.options.server) {
|
|
if (this._server) {
|
|
this._removeListeners();
|
|
this._removeListeners = this._server = null;
|
|
}
|
|
if (this.clients) {
|
|
if (!this.clients.size) {
|
|
process.nextTick(emitClose, this);
|
|
} else {
|
|
this._shouldEmitClose = true;
|
|
}
|
|
} else {
|
|
process.nextTick(emitClose, this);
|
|
}
|
|
} else {
|
|
const server = this._server;
|
|
this._removeListeners();
|
|
this._removeListeners = this._server = null;
|
|
server.close(() => {
|
|
emitClose(this);
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* See if a given request should be handled by this server instance.
|
|
*
|
|
* @param {http.IncomingMessage} req Request object to inspect
|
|
* @return {Boolean} `true` if the request is valid, else `false`
|
|
* @public
|
|
*/
|
|
shouldHandle(req) {
|
|
if (this.options.path) {
|
|
const index = req.url.indexOf("?");
|
|
const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
|
|
if (pathname !== this.options.path) return false;
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Handle a HTTP Upgrade request.
|
|
*
|
|
* @param {http.IncomingMessage} req The request object
|
|
* @param {Duplex} socket The network socket between the server and client
|
|
* @param {Buffer} head The first packet of the upgraded stream
|
|
* @param {Function} cb Callback
|
|
* @public
|
|
*/
|
|
handleUpgrade(req, socket, head, cb) {
|
|
socket.on("error", socketOnError);
|
|
const key = req.headers["sec-websocket-key"];
|
|
const upgrade = req.headers.upgrade;
|
|
const version = +req.headers["sec-websocket-version"];
|
|
if (req.method !== "GET") {
|
|
const message = "Invalid HTTP method";
|
|
abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
|
|
return;
|
|
}
|
|
if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
|
|
const message = "Invalid Upgrade header";
|
|
abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
|
|
return;
|
|
}
|
|
if (key === void 0 || !keyRegex.test(key)) {
|
|
const message = "Missing or invalid Sec-WebSocket-Key header";
|
|
abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
|
|
return;
|
|
}
|
|
if (version !== 13 && version !== 8) {
|
|
const message = "Missing or invalid Sec-WebSocket-Version header";
|
|
abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
|
|
"Sec-WebSocket-Version": "13, 8"
|
|
});
|
|
return;
|
|
}
|
|
if (!this.shouldHandle(req)) {
|
|
abortHandshake(socket, 400);
|
|
return;
|
|
}
|
|
const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
|
|
let protocols = /* @__PURE__ */ new Set();
|
|
if (secWebSocketProtocol !== void 0) {
|
|
try {
|
|
protocols = subprotocol.parse(secWebSocketProtocol);
|
|
} catch (err) {
|
|
const message = "Invalid Sec-WebSocket-Protocol header";
|
|
abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
|
|
return;
|
|
}
|
|
}
|
|
const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
|
|
const extensions = {};
|
|
if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
|
|
const perMessageDeflate = new PerMessageDeflate(
|
|
this.options.perMessageDeflate,
|
|
true,
|
|
this.options.maxPayload
|
|
);
|
|
try {
|
|
const offers = extension.parse(secWebSocketExtensions);
|
|
if (offers[PerMessageDeflate.extensionName]) {
|
|
perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
|
|
extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
|
|
}
|
|
} catch (err) {
|
|
const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
|
|
abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
|
|
return;
|
|
}
|
|
}
|
|
if (this.options.verifyClient) {
|
|
const info = {
|
|
origin: req.headers[`${version === 8 ? "sec-websocket-origin" : "origin"}`],
|
|
secure: !!(req.socket.authorized || req.socket.encrypted),
|
|
req
|
|
};
|
|
if (this.options.verifyClient.length === 2) {
|
|
this.options.verifyClient(info, (verified, code, message, headers) => {
|
|
if (!verified) {
|
|
return abortHandshake(socket, code || 401, message, headers);
|
|
}
|
|
this.completeUpgrade(
|
|
extensions,
|
|
key,
|
|
protocols,
|
|
req,
|
|
socket,
|
|
head,
|
|
cb
|
|
);
|
|
});
|
|
return;
|
|
}
|
|
if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
|
|
}
|
|
this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
|
|
}
|
|
/**
|
|
* Upgrade the connection to WebSocket.
|
|
*
|
|
* @param {Object} extensions The accepted extensions
|
|
* @param {String} key The value of the `Sec-WebSocket-Key` header
|
|
* @param {Set} protocols The subprotocols
|
|
* @param {http.IncomingMessage} req The request object
|
|
* @param {Duplex} socket The network socket between the server and client
|
|
* @param {Buffer} head The first packet of the upgraded stream
|
|
* @param {Function} cb Callback
|
|
* @throws {Error} If called more than once with the same socket
|
|
* @private
|
|
*/
|
|
completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
|
|
if (!socket.readable || !socket.writable) return socket.destroy();
|
|
if (socket[kWebSocket]) {
|
|
throw new Error(
|
|
"server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
|
|
);
|
|
}
|
|
if (this._state > RUNNING) return abortHandshake(socket, 503);
|
|
const digest = createHash("sha1").update(key + GUID).digest("base64");
|
|
const headers = [
|
|
"HTTP/1.1 101 Switching Protocols",
|
|
"Upgrade: websocket",
|
|
"Connection: Upgrade",
|
|
`Sec-WebSocket-Accept: ${digest}`
|
|
];
|
|
const ws = new this.options.WebSocket(null, void 0, this.options);
|
|
if (protocols.size) {
|
|
const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value;
|
|
if (protocol) {
|
|
headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
|
|
ws._protocol = protocol;
|
|
}
|
|
}
|
|
if (extensions[PerMessageDeflate.extensionName]) {
|
|
const params = extensions[PerMessageDeflate.extensionName].params;
|
|
const value = extension.format({
|
|
[PerMessageDeflate.extensionName]: [params]
|
|
});
|
|
headers.push(`Sec-WebSocket-Extensions: ${value}`);
|
|
ws._extensions = extensions;
|
|
}
|
|
this.emit("headers", headers, req);
|
|
socket.write(headers.concat("\r\n").join("\r\n"));
|
|
socket.removeListener("error", socketOnError);
|
|
ws.setSocket(socket, head, {
|
|
allowSynchronousEvents: this.options.allowSynchronousEvents,
|
|
maxPayload: this.options.maxPayload,
|
|
skipUTF8Validation: this.options.skipUTF8Validation
|
|
});
|
|
if (this.clients) {
|
|
this.clients.add(ws);
|
|
ws.on("close", () => {
|
|
this.clients.delete(ws);
|
|
if (this._shouldEmitClose && !this.clients.size) {
|
|
process.nextTick(emitClose, this);
|
|
}
|
|
});
|
|
}
|
|
cb(ws, req);
|
|
}
|
|
};
|
|
module2.exports = WebSocketServer2;
|
|
function addListeners(server, map) {
|
|
for (const event of Object.keys(map)) server.on(event, map[event]);
|
|
return function removeListeners() {
|
|
for (const event of Object.keys(map)) {
|
|
server.removeListener(event, map[event]);
|
|
}
|
|
};
|
|
}
|
|
function emitClose(server) {
|
|
server._state = CLOSED;
|
|
server.emit("close");
|
|
}
|
|
function socketOnError() {
|
|
this.destroy();
|
|
}
|
|
function abortHandshake(socket, code, message, headers) {
|
|
message = message || http.STATUS_CODES[code];
|
|
headers = {
|
|
Connection: "close",
|
|
"Content-Type": "text/html",
|
|
"Content-Length": Buffer.byteLength(message),
|
|
...headers
|
|
};
|
|
socket.once("finish", socket.destroy);
|
|
socket.end(
|
|
`HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
|
|
` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
|
|
);
|
|
}
|
|
function abortHandshakeOrEmitwsClientError(server, req, socket, code, message, headers) {
|
|
if (server.listenerCount("wsClientError")) {
|
|
const err = new Error(message);
|
|
Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
|
|
server.emit("wsClientError", err, socket, req);
|
|
} else {
|
|
abortHandshake(socket, code, message, headers);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js
|
|
var require_kind_of = __commonJS({
|
|
"node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js"(exports2, module2) {
|
|
var toString = Object.prototype.toString;
|
|
module2.exports = function kindOf(val) {
|
|
if (val === void 0) return "undefined";
|
|
if (val === null) return "null";
|
|
var type = typeof val;
|
|
if (type === "boolean") return "boolean";
|
|
if (type === "string") return "string";
|
|
if (type === "number") return "number";
|
|
if (type === "symbol") return "symbol";
|
|
if (type === "function") {
|
|
return isGeneratorFn(val) ? "generatorfunction" : "function";
|
|
}
|
|
if (isArray(val)) return "array";
|
|
if (isBuffer(val)) return "buffer";
|
|
if (isArguments(val)) return "arguments";
|
|
if (isDate(val)) return "date";
|
|
if (isError(val)) return "error";
|
|
if (isRegexp(val)) return "regexp";
|
|
switch (ctorName(val)) {
|
|
case "Symbol":
|
|
return "symbol";
|
|
case "Promise":
|
|
return "promise";
|
|
// Set, Map, WeakSet, WeakMap
|
|
case "WeakMap":
|
|
return "weakmap";
|
|
case "WeakSet":
|
|
return "weakset";
|
|
case "Map":
|
|
return "map";
|
|
case "Set":
|
|
return "set";
|
|
// 8-bit typed arrays
|
|
case "Int8Array":
|
|
return "int8array";
|
|
case "Uint8Array":
|
|
return "uint8array";
|
|
case "Uint8ClampedArray":
|
|
return "uint8clampedarray";
|
|
// 16-bit typed arrays
|
|
case "Int16Array":
|
|
return "int16array";
|
|
case "Uint16Array":
|
|
return "uint16array";
|
|
// 32-bit typed arrays
|
|
case "Int32Array":
|
|
return "int32array";
|
|
case "Uint32Array":
|
|
return "uint32array";
|
|
case "Float32Array":
|
|
return "float32array";
|
|
case "Float64Array":
|
|
return "float64array";
|
|
}
|
|
if (isGeneratorObj(val)) {
|
|
return "generator";
|
|
}
|
|
type = toString.call(val);
|
|
switch (type) {
|
|
case "[object Object]":
|
|
return "object";
|
|
// iterators
|
|
case "[object Map Iterator]":
|
|
return "mapiterator";
|
|
case "[object Set Iterator]":
|
|
return "setiterator";
|
|
case "[object String Iterator]":
|
|
return "stringiterator";
|
|
case "[object Array Iterator]":
|
|
return "arrayiterator";
|
|
}
|
|
return type.slice(8, -1).toLowerCase().replace(/\s/g, "");
|
|
};
|
|
function ctorName(val) {
|
|
return typeof val.constructor === "function" ? val.constructor.name : null;
|
|
}
|
|
function isArray(val) {
|
|
if (Array.isArray) return Array.isArray(val);
|
|
return val instanceof Array;
|
|
}
|
|
function isError(val) {
|
|
return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
|
|
}
|
|
function isDate(val) {
|
|
if (val instanceof Date) return true;
|
|
return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
|
|
}
|
|
function isRegexp(val) {
|
|
if (val instanceof RegExp) return true;
|
|
return typeof val.flags === "string" && typeof val.ignoreCase === "boolean" && typeof val.multiline === "boolean" && typeof val.global === "boolean";
|
|
}
|
|
function isGeneratorFn(name, val) {
|
|
return ctorName(name) === "GeneratorFunction";
|
|
}
|
|
function isGeneratorObj(val) {
|
|
return typeof val.throw === "function" && typeof val.return === "function" && typeof val.next === "function";
|
|
}
|
|
function isArguments(val) {
|
|
try {
|
|
if (typeof val.length === "number" && typeof val.callee === "function") {
|
|
return true;
|
|
}
|
|
} catch (err) {
|
|
if (err.message.indexOf("callee") !== -1) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isBuffer(val) {
|
|
if (val.constructor && typeof val.constructor.isBuffer === "function") {
|
|
return val.constructor.isBuffer(val);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/is-extendable@0.1.1/node_modules/is-extendable/index.js
|
|
var require_is_extendable = __commonJS({
|
|
"node_modules/.pnpm/is-extendable@0.1.1/node_modules/is-extendable/index.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = function isExtendable(val) {
|
|
return typeof val !== "undefined" && val !== null && (typeof val === "object" || typeof val === "function");
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/extend-shallow@2.0.1/node_modules/extend-shallow/index.js
|
|
var require_extend_shallow = __commonJS({
|
|
"node_modules/.pnpm/extend-shallow@2.0.1/node_modules/extend-shallow/index.js"(exports2, module2) {
|
|
"use strict";
|
|
var isObject = require_is_extendable();
|
|
module2.exports = function extend(o) {
|
|
if (!isObject(o)) {
|
|
o = {};
|
|
}
|
|
var len = arguments.length;
|
|
for (var i = 1; i < len; i++) {
|
|
var obj = arguments[i];
|
|
if (isObject(obj)) {
|
|
assign(o, obj);
|
|
}
|
|
}
|
|
return o;
|
|
};
|
|
function assign(a, b) {
|
|
for (var key in b) {
|
|
if (hasOwn(b, key)) {
|
|
a[key] = b[key];
|
|
}
|
|
}
|
|
}
|
|
function hasOwn(obj, key) {
|
|
return Object.prototype.hasOwnProperty.call(obj, key);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/section-matter@1.0.0/node_modules/section-matter/index.js
|
|
var require_section_matter = __commonJS({
|
|
"node_modules/.pnpm/section-matter@1.0.0/node_modules/section-matter/index.js"(exports2, module2) {
|
|
"use strict";
|
|
var typeOf = require_kind_of();
|
|
var extend = require_extend_shallow();
|
|
module2.exports = function(input, options2) {
|
|
if (typeof options2 === "function") {
|
|
options2 = { parse: options2 };
|
|
}
|
|
var file = toObject(input);
|
|
var defaults = { section_delimiter: "---", parse: identity };
|
|
var opts = extend({}, defaults, options2);
|
|
var delim = opts.section_delimiter;
|
|
var lines = file.content.split(/\r?\n/);
|
|
var sections = null;
|
|
var section = createSection();
|
|
var content = [];
|
|
var stack = [];
|
|
function initSections(val) {
|
|
file.content = val;
|
|
sections = [];
|
|
content = [];
|
|
}
|
|
function closeSection(val) {
|
|
if (stack.length) {
|
|
section.key = getKey(stack[0], delim);
|
|
section.content = val;
|
|
opts.parse(section, sections);
|
|
sections.push(section);
|
|
section = createSection();
|
|
content = [];
|
|
stack = [];
|
|
}
|
|
}
|
|
for (var i = 0; i < lines.length; i++) {
|
|
var line = lines[i];
|
|
var len = stack.length;
|
|
var ln = line.trim();
|
|
if (isDelimiter(ln, delim)) {
|
|
if (ln.length === 3 && i !== 0) {
|
|
if (len === 0 || len === 2) {
|
|
content.push(line);
|
|
continue;
|
|
}
|
|
stack.push(ln);
|
|
section.data = content.join("\n");
|
|
content = [];
|
|
continue;
|
|
}
|
|
if (sections === null) {
|
|
initSections(content.join("\n"));
|
|
}
|
|
if (len === 2) {
|
|
closeSection(content.join("\n"));
|
|
}
|
|
stack.push(ln);
|
|
continue;
|
|
}
|
|
content.push(line);
|
|
}
|
|
if (sections === null) {
|
|
initSections(content.join("\n"));
|
|
} else {
|
|
closeSection(content.join("\n"));
|
|
}
|
|
file.sections = sections;
|
|
return file;
|
|
};
|
|
function isDelimiter(line, delim) {
|
|
if (line.slice(0, delim.length) !== delim) {
|
|
return false;
|
|
}
|
|
if (line.charAt(delim.length + 1) === delim.slice(-1)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function toObject(input) {
|
|
if (typeOf(input) !== "object") {
|
|
input = { content: input };
|
|
}
|
|
if (typeof input.content !== "string" && !isBuffer(input.content)) {
|
|
throw new TypeError("expected a buffer or string");
|
|
}
|
|
input.content = input.content.toString();
|
|
input.sections = [];
|
|
return input;
|
|
}
|
|
function getKey(val, delim) {
|
|
return val ? val.slice(delim.length).trim() : "";
|
|
}
|
|
function createSection() {
|
|
return { key: "", data: "", content: "" };
|
|
}
|
|
function identity(val) {
|
|
return val;
|
|
}
|
|
function isBuffer(val) {
|
|
if (val && val.constructor && typeof val.constructor.isBuffer === "function") {
|
|
return val.constructor.isBuffer(val);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/common.js
|
|
var require_common = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/common.js"(exports2, module2) {
|
|
"use strict";
|
|
function isNothing(subject) {
|
|
return typeof subject === "undefined" || subject === null;
|
|
}
|
|
function isObject(subject) {
|
|
return typeof subject === "object" && subject !== null;
|
|
}
|
|
function toArray(sequence) {
|
|
if (Array.isArray(sequence)) return sequence;
|
|
else if (isNothing(sequence)) return [];
|
|
return [sequence];
|
|
}
|
|
function extend(target, source) {
|
|
var index, length, key, sourceKeys;
|
|
if (source) {
|
|
sourceKeys = Object.keys(source);
|
|
for (index = 0, length = sourceKeys.length; index < length; index += 1) {
|
|
key = sourceKeys[index];
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
function repeat(string, count) {
|
|
var result = "", cycle;
|
|
for (cycle = 0; cycle < count; cycle += 1) {
|
|
result += string;
|
|
}
|
|
return result;
|
|
}
|
|
function isNegativeZero(number) {
|
|
return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
|
|
}
|
|
module2.exports.isNothing = isNothing;
|
|
module2.exports.isObject = isObject;
|
|
module2.exports.toArray = toArray;
|
|
module2.exports.repeat = repeat;
|
|
module2.exports.isNegativeZero = isNegativeZero;
|
|
module2.exports.extend = extend;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/exception.js
|
|
var require_exception = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/exception.js"(exports2, module2) {
|
|
"use strict";
|
|
function YAMLException(reason, mark) {
|
|
Error.call(this);
|
|
this.name = "YAMLException";
|
|
this.reason = reason;
|
|
this.mark = mark;
|
|
this.message = (this.reason || "(unknown reason)") + (this.mark ? " " + this.mark.toString() : "");
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
} else {
|
|
this.stack = new Error().stack || "";
|
|
}
|
|
}
|
|
YAMLException.prototype = Object.create(Error.prototype);
|
|
YAMLException.prototype.constructor = YAMLException;
|
|
YAMLException.prototype.toString = function toString(compact) {
|
|
var result = this.name + ": ";
|
|
result += this.reason || "(unknown reason)";
|
|
if (!compact && this.mark) {
|
|
result += " " + this.mark.toString();
|
|
}
|
|
return result;
|
|
};
|
|
module2.exports = YAMLException;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/mark.js
|
|
var require_mark = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/mark.js"(exports2, module2) {
|
|
"use strict";
|
|
var common = require_common();
|
|
function Mark(name, buffer, position, line, column) {
|
|
this.name = name;
|
|
this.buffer = buffer;
|
|
this.position = position;
|
|
this.line = line;
|
|
this.column = column;
|
|
}
|
|
Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
|
|
var head, start, tail, end, snippet;
|
|
if (!this.buffer) return null;
|
|
indent = indent || 4;
|
|
maxLength = maxLength || 75;
|
|
head = "";
|
|
start = this.position;
|
|
while (start > 0 && "\0\r\n\x85\u2028\u2029".indexOf(this.buffer.charAt(start - 1)) === -1) {
|
|
start -= 1;
|
|
if (this.position - start > maxLength / 2 - 1) {
|
|
head = " ... ";
|
|
start += 5;
|
|
break;
|
|
}
|
|
}
|
|
tail = "";
|
|
end = this.position;
|
|
while (end < this.buffer.length && "\0\r\n\x85\u2028\u2029".indexOf(this.buffer.charAt(end)) === -1) {
|
|
end += 1;
|
|
if (end - this.position > maxLength / 2 - 1) {
|
|
tail = " ... ";
|
|
end -= 5;
|
|
break;
|
|
}
|
|
}
|
|
snippet = this.buffer.slice(start, end);
|
|
return common.repeat(" ", indent) + head + snippet + tail + "\n" + common.repeat(" ", indent + this.position - start + head.length) + "^";
|
|
};
|
|
Mark.prototype.toString = function toString(compact) {
|
|
var snippet, where = "";
|
|
if (this.name) {
|
|
where += 'in "' + this.name + '" ';
|
|
}
|
|
where += "at line " + (this.line + 1) + ", column " + (this.column + 1);
|
|
if (!compact) {
|
|
snippet = this.getSnippet();
|
|
if (snippet) {
|
|
where += ":\n" + snippet;
|
|
}
|
|
}
|
|
return where;
|
|
};
|
|
module2.exports = Mark;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js
|
|
var require_type = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type.js"(exports2, module2) {
|
|
"use strict";
|
|
var YAMLException = require_exception();
|
|
var TYPE_CONSTRUCTOR_OPTIONS = [
|
|
"kind",
|
|
"resolve",
|
|
"construct",
|
|
"instanceOf",
|
|
"predicate",
|
|
"represent",
|
|
"defaultStyle",
|
|
"styleAliases"
|
|
];
|
|
var YAML_NODE_KINDS = [
|
|
"scalar",
|
|
"sequence",
|
|
"mapping"
|
|
];
|
|
function compileStyleAliases(map) {
|
|
var result = {};
|
|
if (map !== null) {
|
|
Object.keys(map).forEach(function(style) {
|
|
map[style].forEach(function(alias) {
|
|
result[String(alias)] = style;
|
|
});
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
function Type(tag, options2) {
|
|
options2 = options2 || {};
|
|
Object.keys(options2).forEach(function(name) {
|
|
if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
|
|
throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
|
|
}
|
|
});
|
|
this.tag = tag;
|
|
this.kind = options2["kind"] || null;
|
|
this.resolve = options2["resolve"] || function() {
|
|
return true;
|
|
};
|
|
this.construct = options2["construct"] || function(data) {
|
|
return data;
|
|
};
|
|
this.instanceOf = options2["instanceOf"] || null;
|
|
this.predicate = options2["predicate"] || null;
|
|
this.represent = options2["represent"] || null;
|
|
this.defaultStyle = options2["defaultStyle"] || null;
|
|
this.styleAliases = compileStyleAliases(options2["styleAliases"] || null);
|
|
if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
|
|
throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
|
|
}
|
|
}
|
|
module2.exports = Type;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema.js
|
|
var require_schema = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema.js"(exports2, module2) {
|
|
"use strict";
|
|
var common = require_common();
|
|
var YAMLException = require_exception();
|
|
var Type = require_type();
|
|
function compileList(schema, name, result) {
|
|
var exclude = [];
|
|
schema.include.forEach(function(includedSchema) {
|
|
result = compileList(includedSchema, name, result);
|
|
});
|
|
schema[name].forEach(function(currentType) {
|
|
result.forEach(function(previousType, previousIndex) {
|
|
if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
|
|
exclude.push(previousIndex);
|
|
}
|
|
});
|
|
result.push(currentType);
|
|
});
|
|
return result.filter(function(type, index) {
|
|
return exclude.indexOf(index) === -1;
|
|
});
|
|
}
|
|
function compileMap() {
|
|
var result = {
|
|
scalar: {},
|
|
sequence: {},
|
|
mapping: {},
|
|
fallback: {}
|
|
}, index, length;
|
|
function collectType(type) {
|
|
result[type.kind][type.tag] = result["fallback"][type.tag] = type;
|
|
}
|
|
for (index = 0, length = arguments.length; index < length; index += 1) {
|
|
arguments[index].forEach(collectType);
|
|
}
|
|
return result;
|
|
}
|
|
function Schema(definition) {
|
|
this.include = definition.include || [];
|
|
this.implicit = definition.implicit || [];
|
|
this.explicit = definition.explicit || [];
|
|
this.implicit.forEach(function(type) {
|
|
if (type.loadKind && type.loadKind !== "scalar") {
|
|
throw new YAMLException("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
|
|
}
|
|
});
|
|
this.compiledImplicit = compileList(this, "implicit", []);
|
|
this.compiledExplicit = compileList(this, "explicit", []);
|
|
this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
|
|
}
|
|
Schema.DEFAULT = null;
|
|
Schema.create = function createSchema() {
|
|
var schemas, types;
|
|
switch (arguments.length) {
|
|
case 1:
|
|
schemas = Schema.DEFAULT;
|
|
types = arguments[0];
|
|
break;
|
|
case 2:
|
|
schemas = arguments[0];
|
|
types = arguments[1];
|
|
break;
|
|
default:
|
|
throw new YAMLException("Wrong number of arguments for Schema.create function");
|
|
}
|
|
schemas = common.toArray(schemas);
|
|
types = common.toArray(types);
|
|
if (!schemas.every(function(schema) {
|
|
return schema instanceof Schema;
|
|
})) {
|
|
throw new YAMLException("Specified list of super schemas (or a single Schema object) contains a non-Schema object.");
|
|
}
|
|
if (!types.every(function(type) {
|
|
return type instanceof Type;
|
|
})) {
|
|
throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
|
|
}
|
|
return new Schema({
|
|
include: schemas,
|
|
explicit: types
|
|
});
|
|
};
|
|
module2.exports = Schema;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/str.js
|
|
var require_str = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/str.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
module2.exports = new Type("tag:yaml.org,2002:str", {
|
|
kind: "scalar",
|
|
construct: function(data) {
|
|
return data !== null ? data : "";
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/seq.js
|
|
var require_seq = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/seq.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
module2.exports = new Type("tag:yaml.org,2002:seq", {
|
|
kind: "sequence",
|
|
construct: function(data) {
|
|
return data !== null ? data : [];
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/map.js
|
|
var require_map = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/map.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
module2.exports = new Type("tag:yaml.org,2002:map", {
|
|
kind: "mapping",
|
|
construct: function(data) {
|
|
return data !== null ? data : {};
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js
|
|
var require_failsafe = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/failsafe.js"(exports2, module2) {
|
|
"use strict";
|
|
var Schema = require_schema();
|
|
module2.exports = new Schema({
|
|
explicit: [
|
|
require_str(),
|
|
require_seq(),
|
|
require_map()
|
|
]
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/null.js
|
|
var require_null = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/null.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
function resolveYamlNull(data) {
|
|
if (data === null) return true;
|
|
var max = data.length;
|
|
return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
|
|
}
|
|
function constructYamlNull() {
|
|
return null;
|
|
}
|
|
function isNull(object) {
|
|
return object === null;
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:null", {
|
|
kind: "scalar",
|
|
resolve: resolveYamlNull,
|
|
construct: constructYamlNull,
|
|
predicate: isNull,
|
|
represent: {
|
|
canonical: function() {
|
|
return "~";
|
|
},
|
|
lowercase: function() {
|
|
return "null";
|
|
},
|
|
uppercase: function() {
|
|
return "NULL";
|
|
},
|
|
camelcase: function() {
|
|
return "Null";
|
|
}
|
|
},
|
|
defaultStyle: "lowercase"
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/bool.js
|
|
var require_bool = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/bool.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
function resolveYamlBoolean(data) {
|
|
if (data === null) return false;
|
|
var max = data.length;
|
|
return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
|
|
}
|
|
function constructYamlBoolean(data) {
|
|
return data === "true" || data === "True" || data === "TRUE";
|
|
}
|
|
function isBoolean(object) {
|
|
return Object.prototype.toString.call(object) === "[object Boolean]";
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:bool", {
|
|
kind: "scalar",
|
|
resolve: resolveYamlBoolean,
|
|
construct: constructYamlBoolean,
|
|
predicate: isBoolean,
|
|
represent: {
|
|
lowercase: function(object) {
|
|
return object ? "true" : "false";
|
|
},
|
|
uppercase: function(object) {
|
|
return object ? "TRUE" : "FALSE";
|
|
},
|
|
camelcase: function(object) {
|
|
return object ? "True" : "False";
|
|
}
|
|
},
|
|
defaultStyle: "lowercase"
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/int.js
|
|
var require_int = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/int.js"(exports2, module2) {
|
|
"use strict";
|
|
var common = require_common();
|
|
var Type = require_type();
|
|
function isHexCode(c) {
|
|
return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102;
|
|
}
|
|
function isOctCode(c) {
|
|
return 48 <= c && c <= 55;
|
|
}
|
|
function isDecCode(c) {
|
|
return 48 <= c && c <= 57;
|
|
}
|
|
function resolveYamlInteger(data) {
|
|
if (data === null) return false;
|
|
var max = data.length, index = 0, hasDigits = false, ch;
|
|
if (!max) return false;
|
|
ch = data[index];
|
|
if (ch === "-" || ch === "+") {
|
|
ch = data[++index];
|
|
}
|
|
if (ch === "0") {
|
|
if (index + 1 === max) return true;
|
|
ch = data[++index];
|
|
if (ch === "b") {
|
|
index++;
|
|
for (; index < max; index++) {
|
|
ch = data[index];
|
|
if (ch === "_") continue;
|
|
if (ch !== "0" && ch !== "1") return false;
|
|
hasDigits = true;
|
|
}
|
|
return hasDigits && ch !== "_";
|
|
}
|
|
if (ch === "x") {
|
|
index++;
|
|
for (; index < max; index++) {
|
|
ch = data[index];
|
|
if (ch === "_") continue;
|
|
if (!isHexCode(data.charCodeAt(index))) return false;
|
|
hasDigits = true;
|
|
}
|
|
return hasDigits && ch !== "_";
|
|
}
|
|
for (; index < max; index++) {
|
|
ch = data[index];
|
|
if (ch === "_") continue;
|
|
if (!isOctCode(data.charCodeAt(index))) return false;
|
|
hasDigits = true;
|
|
}
|
|
return hasDigits && ch !== "_";
|
|
}
|
|
if (ch === "_") return false;
|
|
for (; index < max; index++) {
|
|
ch = data[index];
|
|
if (ch === "_") continue;
|
|
if (ch === ":") break;
|
|
if (!isDecCode(data.charCodeAt(index))) {
|
|
return false;
|
|
}
|
|
hasDigits = true;
|
|
}
|
|
if (!hasDigits || ch === "_") return false;
|
|
if (ch !== ":") return true;
|
|
return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
|
|
}
|
|
function constructYamlInteger(data) {
|
|
var value = data, sign = 1, ch, base, digits = [];
|
|
if (value.indexOf("_") !== -1) {
|
|
value = value.replace(/_/g, "");
|
|
}
|
|
ch = value[0];
|
|
if (ch === "-" || ch === "+") {
|
|
if (ch === "-") sign = -1;
|
|
value = value.slice(1);
|
|
ch = value[0];
|
|
}
|
|
if (value === "0") return 0;
|
|
if (ch === "0") {
|
|
if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
|
|
if (value[1] === "x") return sign * parseInt(value, 16);
|
|
return sign * parseInt(value, 8);
|
|
}
|
|
if (value.indexOf(":") !== -1) {
|
|
value.split(":").forEach(function(v) {
|
|
digits.unshift(parseInt(v, 10));
|
|
});
|
|
value = 0;
|
|
base = 1;
|
|
digits.forEach(function(d) {
|
|
value += d * base;
|
|
base *= 60;
|
|
});
|
|
return sign * value;
|
|
}
|
|
return sign * parseInt(value, 10);
|
|
}
|
|
function isInteger(object) {
|
|
return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object));
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:int", {
|
|
kind: "scalar",
|
|
resolve: resolveYamlInteger,
|
|
construct: constructYamlInteger,
|
|
predicate: isInteger,
|
|
represent: {
|
|
binary: function(obj) {
|
|
return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
|
|
},
|
|
octal: function(obj) {
|
|
return obj >= 0 ? "0" + obj.toString(8) : "-0" + obj.toString(8).slice(1);
|
|
},
|
|
decimal: function(obj) {
|
|
return obj.toString(10);
|
|
},
|
|
/* eslint-disable max-len */
|
|
hexadecimal: function(obj) {
|
|
return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
|
|
}
|
|
},
|
|
defaultStyle: "decimal",
|
|
styleAliases: {
|
|
binary: [2, "bin"],
|
|
octal: [8, "oct"],
|
|
decimal: [10, "dec"],
|
|
hexadecimal: [16, "hex"]
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/float.js
|
|
var require_float = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/float.js"(exports2, module2) {
|
|
"use strict";
|
|
var common = require_common();
|
|
var Type = require_type();
|
|
var YAML_FLOAT_PATTERN = new RegExp(
|
|
// 2.5e4, 2.5 and integers
|
|
"^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"
|
|
);
|
|
function resolveYamlFloat(data) {
|
|
if (data === null) return false;
|
|
if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_`
|
|
// Probably should update regexp & check speed
|
|
data[data.length - 1] === "_") {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function constructYamlFloat(data) {
|
|
var value, sign, base, digits;
|
|
value = data.replace(/_/g, "").toLowerCase();
|
|
sign = value[0] === "-" ? -1 : 1;
|
|
digits = [];
|
|
if ("+-".indexOf(value[0]) >= 0) {
|
|
value = value.slice(1);
|
|
}
|
|
if (value === ".inf") {
|
|
return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
|
|
} else if (value === ".nan") {
|
|
return NaN;
|
|
} else if (value.indexOf(":") >= 0) {
|
|
value.split(":").forEach(function(v) {
|
|
digits.unshift(parseFloat(v, 10));
|
|
});
|
|
value = 0;
|
|
base = 1;
|
|
digits.forEach(function(d) {
|
|
value += d * base;
|
|
base *= 60;
|
|
});
|
|
return sign * value;
|
|
}
|
|
return sign * parseFloat(value, 10);
|
|
}
|
|
var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
|
|
function representYamlFloat(object, style) {
|
|
var res;
|
|
if (isNaN(object)) {
|
|
switch (style) {
|
|
case "lowercase":
|
|
return ".nan";
|
|
case "uppercase":
|
|
return ".NAN";
|
|
case "camelcase":
|
|
return ".NaN";
|
|
}
|
|
} else if (Number.POSITIVE_INFINITY === object) {
|
|
switch (style) {
|
|
case "lowercase":
|
|
return ".inf";
|
|
case "uppercase":
|
|
return ".INF";
|
|
case "camelcase":
|
|
return ".Inf";
|
|
}
|
|
} else if (Number.NEGATIVE_INFINITY === object) {
|
|
switch (style) {
|
|
case "lowercase":
|
|
return "-.inf";
|
|
case "uppercase":
|
|
return "-.INF";
|
|
case "camelcase":
|
|
return "-.Inf";
|
|
}
|
|
} else if (common.isNegativeZero(object)) {
|
|
return "-0.0";
|
|
}
|
|
res = object.toString(10);
|
|
return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
|
|
}
|
|
function isFloat(object) {
|
|
return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:float", {
|
|
kind: "scalar",
|
|
resolve: resolveYamlFloat,
|
|
construct: constructYamlFloat,
|
|
predicate: isFloat,
|
|
represent: representYamlFloat,
|
|
defaultStyle: "lowercase"
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/json.js
|
|
var require_json = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/json.js"(exports2, module2) {
|
|
"use strict";
|
|
var Schema = require_schema();
|
|
module2.exports = new Schema({
|
|
include: [
|
|
require_failsafe()
|
|
],
|
|
implicit: [
|
|
require_null(),
|
|
require_bool(),
|
|
require_int(),
|
|
require_float()
|
|
]
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/core.js
|
|
var require_core = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/core.js"(exports2, module2) {
|
|
"use strict";
|
|
var Schema = require_schema();
|
|
module2.exports = new Schema({
|
|
include: [
|
|
require_json()
|
|
]
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/timestamp.js
|
|
var require_timestamp = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/timestamp.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
var YAML_DATE_REGEXP = new RegExp(
|
|
"^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"
|
|
);
|
|
var YAML_TIMESTAMP_REGEXP = new RegExp(
|
|
"^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$"
|
|
);
|
|
function resolveYamlTimestamp(data) {
|
|
if (data === null) return false;
|
|
if (YAML_DATE_REGEXP.exec(data) !== null) return true;
|
|
if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
|
|
return false;
|
|
}
|
|
function constructYamlTimestamp(data) {
|
|
var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
|
|
match = YAML_DATE_REGEXP.exec(data);
|
|
if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
|
|
if (match === null) throw new Error("Date resolve error");
|
|
year = +match[1];
|
|
month = +match[2] - 1;
|
|
day = +match[3];
|
|
if (!match[4]) {
|
|
return new Date(Date.UTC(year, month, day));
|
|
}
|
|
hour = +match[4];
|
|
minute = +match[5];
|
|
second = +match[6];
|
|
if (match[7]) {
|
|
fraction = match[7].slice(0, 3);
|
|
while (fraction.length < 3) {
|
|
fraction += "0";
|
|
}
|
|
fraction = +fraction;
|
|
}
|
|
if (match[9]) {
|
|
tz_hour = +match[10];
|
|
tz_minute = +(match[11] || 0);
|
|
delta = (tz_hour * 60 + tz_minute) * 6e4;
|
|
if (match[9] === "-") delta = -delta;
|
|
}
|
|
date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
|
|
if (delta) date.setTime(date.getTime() - delta);
|
|
return date;
|
|
}
|
|
function representYamlTimestamp(object) {
|
|
return object.toISOString();
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:timestamp", {
|
|
kind: "scalar",
|
|
resolve: resolveYamlTimestamp,
|
|
construct: constructYamlTimestamp,
|
|
instanceOf: Date,
|
|
represent: representYamlTimestamp
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/merge.js
|
|
var require_merge = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/merge.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
function resolveYamlMerge(data) {
|
|
return data === "<<" || data === null;
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:merge", {
|
|
kind: "scalar",
|
|
resolve: resolveYamlMerge
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/binary.js
|
|
var require_binary = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/binary.js"(exports2, module2) {
|
|
"use strict";
|
|
var NodeBuffer;
|
|
try {
|
|
_require = require;
|
|
NodeBuffer = _require("buffer").Buffer;
|
|
} catch (__) {
|
|
}
|
|
var _require;
|
|
var Type = require_type();
|
|
var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
|
|
function resolveYamlBinary(data) {
|
|
if (data === null) return false;
|
|
var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
|
|
for (idx = 0; idx < max; idx++) {
|
|
code = map.indexOf(data.charAt(idx));
|
|
if (code > 64) continue;
|
|
if (code < 0) return false;
|
|
bitlen += 6;
|
|
}
|
|
return bitlen % 8 === 0;
|
|
}
|
|
function constructYamlBinary(data) {
|
|
var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map = BASE64_MAP, bits = 0, result = [];
|
|
for (idx = 0; idx < max; idx++) {
|
|
if (idx % 4 === 0 && idx) {
|
|
result.push(bits >> 16 & 255);
|
|
result.push(bits >> 8 & 255);
|
|
result.push(bits & 255);
|
|
}
|
|
bits = bits << 6 | map.indexOf(input.charAt(idx));
|
|
}
|
|
tailbits = max % 4 * 6;
|
|
if (tailbits === 0) {
|
|
result.push(bits >> 16 & 255);
|
|
result.push(bits >> 8 & 255);
|
|
result.push(bits & 255);
|
|
} else if (tailbits === 18) {
|
|
result.push(bits >> 10 & 255);
|
|
result.push(bits >> 2 & 255);
|
|
} else if (tailbits === 12) {
|
|
result.push(bits >> 4 & 255);
|
|
}
|
|
if (NodeBuffer) {
|
|
return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);
|
|
}
|
|
return result;
|
|
}
|
|
function representYamlBinary(object) {
|
|
var result = "", bits = 0, idx, tail, max = object.length, map = BASE64_MAP;
|
|
for (idx = 0; idx < max; idx++) {
|
|
if (idx % 3 === 0 && idx) {
|
|
result += map[bits >> 18 & 63];
|
|
result += map[bits >> 12 & 63];
|
|
result += map[bits >> 6 & 63];
|
|
result += map[bits & 63];
|
|
}
|
|
bits = (bits << 8) + object[idx];
|
|
}
|
|
tail = max % 3;
|
|
if (tail === 0) {
|
|
result += map[bits >> 18 & 63];
|
|
result += map[bits >> 12 & 63];
|
|
result += map[bits >> 6 & 63];
|
|
result += map[bits & 63];
|
|
} else if (tail === 2) {
|
|
result += map[bits >> 10 & 63];
|
|
result += map[bits >> 4 & 63];
|
|
result += map[bits << 2 & 63];
|
|
result += map[64];
|
|
} else if (tail === 1) {
|
|
result += map[bits >> 2 & 63];
|
|
result += map[bits << 4 & 63];
|
|
result += map[64];
|
|
result += map[64];
|
|
}
|
|
return result;
|
|
}
|
|
function isBinary(object) {
|
|
return NodeBuffer && NodeBuffer.isBuffer(object);
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:binary", {
|
|
kind: "scalar",
|
|
resolve: resolveYamlBinary,
|
|
construct: constructYamlBinary,
|
|
predicate: isBinary,
|
|
represent: representYamlBinary
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/omap.js
|
|
var require_omap = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/omap.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
var _hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
var _toString = Object.prototype.toString;
|
|
function resolveYamlOmap(data) {
|
|
if (data === null) return true;
|
|
var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data;
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
pair = object[index];
|
|
pairHasKey = false;
|
|
if (_toString.call(pair) !== "[object Object]") return false;
|
|
for (pairKey in pair) {
|
|
if (_hasOwnProperty.call(pair, pairKey)) {
|
|
if (!pairHasKey) pairHasKey = true;
|
|
else return false;
|
|
}
|
|
}
|
|
if (!pairHasKey) return false;
|
|
if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
|
|
else return false;
|
|
}
|
|
return true;
|
|
}
|
|
function constructYamlOmap(data) {
|
|
return data !== null ? data : [];
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:omap", {
|
|
kind: "sequence",
|
|
resolve: resolveYamlOmap,
|
|
construct: constructYamlOmap
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/pairs.js
|
|
var require_pairs = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/pairs.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
var _toString = Object.prototype.toString;
|
|
function resolveYamlPairs(data) {
|
|
if (data === null) return true;
|
|
var index, length, pair, keys, result, object = data;
|
|
result = new Array(object.length);
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
pair = object[index];
|
|
if (_toString.call(pair) !== "[object Object]") return false;
|
|
keys = Object.keys(pair);
|
|
if (keys.length !== 1) return false;
|
|
result[index] = [keys[0], pair[keys[0]]];
|
|
}
|
|
return true;
|
|
}
|
|
function constructYamlPairs(data) {
|
|
if (data === null) return [];
|
|
var index, length, pair, keys, result, object = data;
|
|
result = new Array(object.length);
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
pair = object[index];
|
|
keys = Object.keys(pair);
|
|
result[index] = [keys[0], pair[keys[0]]];
|
|
}
|
|
return result;
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:pairs", {
|
|
kind: "sequence",
|
|
resolve: resolveYamlPairs,
|
|
construct: constructYamlPairs
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/set.js
|
|
var require_set = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/set.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
var _hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
function resolveYamlSet(data) {
|
|
if (data === null) return true;
|
|
var key, object = data;
|
|
for (key in object) {
|
|
if (_hasOwnProperty.call(object, key)) {
|
|
if (object[key] !== null) return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function constructYamlSet(data) {
|
|
return data !== null ? data : {};
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:set", {
|
|
kind: "mapping",
|
|
resolve: resolveYamlSet,
|
|
construct: constructYamlSet
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js
|
|
var require_default_safe = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_safe.js"(exports2, module2) {
|
|
"use strict";
|
|
var Schema = require_schema();
|
|
module2.exports = new Schema({
|
|
include: [
|
|
require_core()
|
|
],
|
|
implicit: [
|
|
require_timestamp(),
|
|
require_merge()
|
|
],
|
|
explicit: [
|
|
require_binary(),
|
|
require_omap(),
|
|
require_pairs(),
|
|
require_set()
|
|
]
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js
|
|
var require_undefined = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
function resolveJavascriptUndefined() {
|
|
return true;
|
|
}
|
|
function constructJavascriptUndefined() {
|
|
return void 0;
|
|
}
|
|
function representJavascriptUndefined() {
|
|
return "";
|
|
}
|
|
function isUndefined(object) {
|
|
return typeof object === "undefined";
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:js/undefined", {
|
|
kind: "scalar",
|
|
resolve: resolveJavascriptUndefined,
|
|
construct: constructJavascriptUndefined,
|
|
predicate: isUndefined,
|
|
represent: representJavascriptUndefined
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js
|
|
var require_regexp = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js"(exports2, module2) {
|
|
"use strict";
|
|
var Type = require_type();
|
|
function resolveJavascriptRegExp(data) {
|
|
if (data === null) return false;
|
|
if (data.length === 0) return false;
|
|
var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = "";
|
|
if (regexp[0] === "/") {
|
|
if (tail) modifiers = tail[1];
|
|
if (modifiers.length > 3) return false;
|
|
if (regexp[regexp.length - modifiers.length - 1] !== "/") return false;
|
|
}
|
|
return true;
|
|
}
|
|
function constructJavascriptRegExp(data) {
|
|
var regexp = data, tail = /\/([gim]*)$/.exec(data), modifiers = "";
|
|
if (regexp[0] === "/") {
|
|
if (tail) modifiers = tail[1];
|
|
regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
|
|
}
|
|
return new RegExp(regexp, modifiers);
|
|
}
|
|
function representJavascriptRegExp(object) {
|
|
var result = "/" + object.source + "/";
|
|
if (object.global) result += "g";
|
|
if (object.multiline) result += "m";
|
|
if (object.ignoreCase) result += "i";
|
|
return result;
|
|
}
|
|
function isRegExp(object) {
|
|
return Object.prototype.toString.call(object) === "[object RegExp]";
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:js/regexp", {
|
|
kind: "scalar",
|
|
resolve: resolveJavascriptRegExp,
|
|
construct: constructJavascriptRegExp,
|
|
predicate: isRegExp,
|
|
represent: representJavascriptRegExp
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/function.js
|
|
var require_function = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/type/js/function.js"(exports2, module2) {
|
|
"use strict";
|
|
var esprima;
|
|
try {
|
|
_require = require;
|
|
esprima = _require("esprima");
|
|
} catch (_) {
|
|
if (typeof window !== "undefined") esprima = window.esprima;
|
|
}
|
|
var _require;
|
|
var Type = require_type();
|
|
function resolveJavascriptFunction(data) {
|
|
if (data === null) return false;
|
|
try {
|
|
var source = "(" + data + ")", ast = esprima.parse(source, { range: true });
|
|
if (ast.type !== "Program" || ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement" || ast.body[0].expression.type !== "ArrowFunctionExpression" && ast.body[0].expression.type !== "FunctionExpression") {
|
|
return false;
|
|
}
|
|
return true;
|
|
} catch (err) {
|
|
return false;
|
|
}
|
|
}
|
|
function constructJavascriptFunction(data) {
|
|
var source = "(" + data + ")", ast = esprima.parse(source, { range: true }), params = [], body;
|
|
if (ast.type !== "Program" || ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement" || ast.body[0].expression.type !== "ArrowFunctionExpression" && ast.body[0].expression.type !== "FunctionExpression") {
|
|
throw new Error("Failed to resolve function");
|
|
}
|
|
ast.body[0].expression.params.forEach(function(param) {
|
|
params.push(param.name);
|
|
});
|
|
body = ast.body[0].expression.body.range;
|
|
if (ast.body[0].expression.body.type === "BlockStatement") {
|
|
return new Function(params, source.slice(body[0] + 1, body[1] - 1));
|
|
}
|
|
return new Function(params, "return " + source.slice(body[0], body[1]));
|
|
}
|
|
function representJavascriptFunction(object) {
|
|
return object.toString();
|
|
}
|
|
function isFunction(object) {
|
|
return Object.prototype.toString.call(object) === "[object Function]";
|
|
}
|
|
module2.exports = new Type("tag:yaml.org,2002:js/function", {
|
|
kind: "scalar",
|
|
resolve: resolveJavascriptFunction,
|
|
construct: constructJavascriptFunction,
|
|
predicate: isFunction,
|
|
represent: representJavascriptFunction
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_full.js
|
|
var require_default_full = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/schema/default_full.js"(exports2, module2) {
|
|
"use strict";
|
|
var Schema = require_schema();
|
|
module2.exports = Schema.DEFAULT = new Schema({
|
|
include: [
|
|
require_default_safe()
|
|
],
|
|
explicit: [
|
|
require_undefined(),
|
|
require_regexp(),
|
|
require_function()
|
|
]
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/loader.js
|
|
var require_loader = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/loader.js"(exports2, module2) {
|
|
"use strict";
|
|
var common = require_common();
|
|
var YAMLException = require_exception();
|
|
var Mark = require_mark();
|
|
var DEFAULT_SAFE_SCHEMA = require_default_safe();
|
|
var DEFAULT_FULL_SCHEMA = require_default_full();
|
|
var _hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
var CONTEXT_FLOW_IN = 1;
|
|
var CONTEXT_FLOW_OUT = 2;
|
|
var CONTEXT_BLOCK_IN = 3;
|
|
var CONTEXT_BLOCK_OUT = 4;
|
|
var CHOMPING_CLIP = 1;
|
|
var CHOMPING_STRIP = 2;
|
|
var CHOMPING_KEEP = 3;
|
|
var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
|
|
var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
|
|
var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
|
|
var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
|
|
var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
|
|
function _class(obj) {
|
|
return Object.prototype.toString.call(obj);
|
|
}
|
|
function is_EOL(c) {
|
|
return c === 10 || c === 13;
|
|
}
|
|
function is_WHITE_SPACE(c) {
|
|
return c === 9 || c === 32;
|
|
}
|
|
function is_WS_OR_EOL(c) {
|
|
return c === 9 || c === 32 || c === 10 || c === 13;
|
|
}
|
|
function is_FLOW_INDICATOR(c) {
|
|
return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
|
|
}
|
|
function fromHexCode(c) {
|
|
var lc;
|
|
if (48 <= c && c <= 57) {
|
|
return c - 48;
|
|
}
|
|
lc = c | 32;
|
|
if (97 <= lc && lc <= 102) {
|
|
return lc - 97 + 10;
|
|
}
|
|
return -1;
|
|
}
|
|
function escapedHexLen(c) {
|
|
if (c === 120) {
|
|
return 2;
|
|
}
|
|
if (c === 117) {
|
|
return 4;
|
|
}
|
|
if (c === 85) {
|
|
return 8;
|
|
}
|
|
return 0;
|
|
}
|
|
function fromDecimalCode(c) {
|
|
if (48 <= c && c <= 57) {
|
|
return c - 48;
|
|
}
|
|
return -1;
|
|
}
|
|
function simpleEscapeSequence(c) {
|
|
return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? " " : c === 9 ? " " : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\x1B" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "\x85" : c === 95 ? "\xA0" : c === 76 ? "\u2028" : c === 80 ? "\u2029" : "";
|
|
}
|
|
function charFromCodepoint(c) {
|
|
if (c <= 65535) {
|
|
return String.fromCharCode(c);
|
|
}
|
|
return String.fromCharCode(
|
|
(c - 65536 >> 10) + 55296,
|
|
(c - 65536 & 1023) + 56320
|
|
);
|
|
}
|
|
function setProperty(object, key, value) {
|
|
if (key === "__proto__") {
|
|
Object.defineProperty(object, key, {
|
|
configurable: true,
|
|
enumerable: true,
|
|
writable: true,
|
|
value
|
|
});
|
|
} else {
|
|
object[key] = value;
|
|
}
|
|
}
|
|
var simpleEscapeCheck = new Array(256);
|
|
var simpleEscapeMap = new Array(256);
|
|
for (i = 0; i < 256; i++) {
|
|
simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
|
|
simpleEscapeMap[i] = simpleEscapeSequence(i);
|
|
}
|
|
var i;
|
|
function State(input, options2) {
|
|
this.input = input;
|
|
this.filename = options2["filename"] || null;
|
|
this.schema = options2["schema"] || DEFAULT_FULL_SCHEMA;
|
|
this.onWarning = options2["onWarning"] || null;
|
|
this.legacy = options2["legacy"] || false;
|
|
this.json = options2["json"] || false;
|
|
this.listener = options2["listener"] || null;
|
|
this.implicitTypes = this.schema.compiledImplicit;
|
|
this.typeMap = this.schema.compiledTypeMap;
|
|
this.length = input.length;
|
|
this.position = 0;
|
|
this.line = 0;
|
|
this.lineStart = 0;
|
|
this.lineIndent = 0;
|
|
this.documents = [];
|
|
}
|
|
function generateError(state, message) {
|
|
return new YAMLException(
|
|
message,
|
|
new Mark(state.filename, state.input, state.position, state.line, state.position - state.lineStart)
|
|
);
|
|
}
|
|
function throwError(state, message) {
|
|
throw generateError(state, message);
|
|
}
|
|
function throwWarning(state, message) {
|
|
if (state.onWarning) {
|
|
state.onWarning.call(null, generateError(state, message));
|
|
}
|
|
}
|
|
var directiveHandlers = {
|
|
YAML: function handleYamlDirective(state, name, args) {
|
|
var match, major, minor;
|
|
if (state.version !== null) {
|
|
throwError(state, "duplication of %YAML directive");
|
|
}
|
|
if (args.length !== 1) {
|
|
throwError(state, "YAML directive accepts exactly one argument");
|
|
}
|
|
match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
|
|
if (match === null) {
|
|
throwError(state, "ill-formed argument of the YAML directive");
|
|
}
|
|
major = parseInt(match[1], 10);
|
|
minor = parseInt(match[2], 10);
|
|
if (major !== 1) {
|
|
throwError(state, "unacceptable YAML version of the document");
|
|
}
|
|
state.version = args[0];
|
|
state.checkLineBreaks = minor < 2;
|
|
if (minor !== 1 && minor !== 2) {
|
|
throwWarning(state, "unsupported YAML version of the document");
|
|
}
|
|
},
|
|
TAG: function handleTagDirective(state, name, args) {
|
|
var handle, prefix;
|
|
if (args.length !== 2) {
|
|
throwError(state, "TAG directive accepts exactly two arguments");
|
|
}
|
|
handle = args[0];
|
|
prefix = args[1];
|
|
if (!PATTERN_TAG_HANDLE.test(handle)) {
|
|
throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
|
|
}
|
|
if (_hasOwnProperty.call(state.tagMap, handle)) {
|
|
throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
|
|
}
|
|
if (!PATTERN_TAG_URI.test(prefix)) {
|
|
throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
|
|
}
|
|
state.tagMap[handle] = prefix;
|
|
}
|
|
};
|
|
function captureSegment(state, start, end, checkJson) {
|
|
var _position, _length, _character, _result;
|
|
if (start < end) {
|
|
_result = state.input.slice(start, end);
|
|
if (checkJson) {
|
|
for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
|
|
_character = _result.charCodeAt(_position);
|
|
if (!(_character === 9 || 32 <= _character && _character <= 1114111)) {
|
|
throwError(state, "expected valid JSON character");
|
|
}
|
|
}
|
|
} else if (PATTERN_NON_PRINTABLE.test(_result)) {
|
|
throwError(state, "the stream contains non-printable characters");
|
|
}
|
|
state.result += _result;
|
|
}
|
|
}
|
|
function mergeMappings(state, destination, source, overridableKeys) {
|
|
var sourceKeys, key, index, quantity;
|
|
if (!common.isObject(source)) {
|
|
throwError(state, "cannot merge mappings; the provided source object is unacceptable");
|
|
}
|
|
sourceKeys = Object.keys(source);
|
|
for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
|
|
key = sourceKeys[index];
|
|
if (!_hasOwnProperty.call(destination, key)) {
|
|
setProperty(destination, key, source[key]);
|
|
overridableKeys[key] = true;
|
|
}
|
|
}
|
|
}
|
|
function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
|
|
var index, quantity;
|
|
if (Array.isArray(keyNode)) {
|
|
keyNode = Array.prototype.slice.call(keyNode);
|
|
for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
|
|
if (Array.isArray(keyNode[index])) {
|
|
throwError(state, "nested arrays are not supported inside keys");
|
|
}
|
|
if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") {
|
|
keyNode[index] = "[object Object]";
|
|
}
|
|
}
|
|
}
|
|
if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") {
|
|
keyNode = "[object Object]";
|
|
}
|
|
keyNode = String(keyNode);
|
|
if (_result === null) {
|
|
_result = {};
|
|
}
|
|
if (keyTag === "tag:yaml.org,2002:merge") {
|
|
if (Array.isArray(valueNode)) {
|
|
for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
|
|
mergeMappings(state, _result, valueNode[index], overridableKeys);
|
|
}
|
|
} else {
|
|
mergeMappings(state, _result, valueNode, overridableKeys);
|
|
}
|
|
} else {
|
|
if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
|
|
state.line = startLine || state.line;
|
|
state.position = startPos || state.position;
|
|
throwError(state, "duplicated mapping key");
|
|
}
|
|
setProperty(_result, keyNode, valueNode);
|
|
delete overridableKeys[keyNode];
|
|
}
|
|
return _result;
|
|
}
|
|
function readLineBreak(state) {
|
|
var ch;
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (ch === 10) {
|
|
state.position++;
|
|
} else if (ch === 13) {
|
|
state.position++;
|
|
if (state.input.charCodeAt(state.position) === 10) {
|
|
state.position++;
|
|
}
|
|
} else {
|
|
throwError(state, "a line break is expected");
|
|
}
|
|
state.line += 1;
|
|
state.lineStart = state.position;
|
|
}
|
|
function skipSeparationSpace(state, allowComments, checkIndent) {
|
|
var lineBreaks = 0, ch = state.input.charCodeAt(state.position);
|
|
while (ch !== 0) {
|
|
while (is_WHITE_SPACE(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
if (allowComments && ch === 35) {
|
|
do {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} while (ch !== 10 && ch !== 13 && ch !== 0);
|
|
}
|
|
if (is_EOL(ch)) {
|
|
readLineBreak(state);
|
|
ch = state.input.charCodeAt(state.position);
|
|
lineBreaks++;
|
|
state.lineIndent = 0;
|
|
while (ch === 32) {
|
|
state.lineIndent++;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
|
|
throwWarning(state, "deficient indentation");
|
|
}
|
|
return lineBreaks;
|
|
}
|
|
function testDocumentSeparator(state) {
|
|
var _position = state.position, ch;
|
|
ch = state.input.charCodeAt(_position);
|
|
if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
|
|
_position += 3;
|
|
ch = state.input.charCodeAt(_position);
|
|
if (ch === 0 || is_WS_OR_EOL(ch)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function writeFoldedLines(state, count) {
|
|
if (count === 1) {
|
|
state.result += " ";
|
|
} else if (count > 1) {
|
|
state.result += common.repeat("\n", count - 1);
|
|
}
|
|
}
|
|
function readPlainScalar(state, nodeIndent, withinFlowCollection) {
|
|
var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch;
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) {
|
|
return false;
|
|
}
|
|
if (ch === 63 || ch === 45) {
|
|
following = state.input.charCodeAt(state.position + 1);
|
|
if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
|
|
return false;
|
|
}
|
|
}
|
|
state.kind = "scalar";
|
|
state.result = "";
|
|
captureStart = captureEnd = state.position;
|
|
hasPendingContent = false;
|
|
while (ch !== 0) {
|
|
if (ch === 58) {
|
|
following = state.input.charCodeAt(state.position + 1);
|
|
if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
|
|
break;
|
|
}
|
|
} else if (ch === 35) {
|
|
preceding = state.input.charCodeAt(state.position - 1);
|
|
if (is_WS_OR_EOL(preceding)) {
|
|
break;
|
|
}
|
|
} else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch)) {
|
|
break;
|
|
} else if (is_EOL(ch)) {
|
|
_line = state.line;
|
|
_lineStart = state.lineStart;
|
|
_lineIndent = state.lineIndent;
|
|
skipSeparationSpace(state, false, -1);
|
|
if (state.lineIndent >= nodeIndent) {
|
|
hasPendingContent = true;
|
|
ch = state.input.charCodeAt(state.position);
|
|
continue;
|
|
} else {
|
|
state.position = captureEnd;
|
|
state.line = _line;
|
|
state.lineStart = _lineStart;
|
|
state.lineIndent = _lineIndent;
|
|
break;
|
|
}
|
|
}
|
|
if (hasPendingContent) {
|
|
captureSegment(state, captureStart, captureEnd, false);
|
|
writeFoldedLines(state, state.line - _line);
|
|
captureStart = captureEnd = state.position;
|
|
hasPendingContent = false;
|
|
}
|
|
if (!is_WHITE_SPACE(ch)) {
|
|
captureEnd = state.position + 1;
|
|
}
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
captureSegment(state, captureStart, captureEnd, false);
|
|
if (state.result) {
|
|
return true;
|
|
}
|
|
state.kind = _kind;
|
|
state.result = _result;
|
|
return false;
|
|
}
|
|
function readSingleQuotedScalar(state, nodeIndent) {
|
|
var ch, captureStart, captureEnd;
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (ch !== 39) {
|
|
return false;
|
|
}
|
|
state.kind = "scalar";
|
|
state.result = "";
|
|
state.position++;
|
|
captureStart = captureEnd = state.position;
|
|
while ((ch = state.input.charCodeAt(state.position)) !== 0) {
|
|
if (ch === 39) {
|
|
captureSegment(state, captureStart, state.position, true);
|
|
ch = state.input.charCodeAt(++state.position);
|
|
if (ch === 39) {
|
|
captureStart = state.position;
|
|
state.position++;
|
|
captureEnd = state.position;
|
|
} else {
|
|
return true;
|
|
}
|
|
} else if (is_EOL(ch)) {
|
|
captureSegment(state, captureStart, captureEnd, true);
|
|
writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
|
|
captureStart = captureEnd = state.position;
|
|
} else if (state.position === state.lineStart && testDocumentSeparator(state)) {
|
|
throwError(state, "unexpected end of the document within a single quoted scalar");
|
|
} else {
|
|
state.position++;
|
|
captureEnd = state.position;
|
|
}
|
|
}
|
|
throwError(state, "unexpected end of the stream within a single quoted scalar");
|
|
}
|
|
function readDoubleQuotedScalar(state, nodeIndent) {
|
|
var captureStart, captureEnd, hexLength, hexResult, tmp, ch;
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (ch !== 34) {
|
|
return false;
|
|
}
|
|
state.kind = "scalar";
|
|
state.result = "";
|
|
state.position++;
|
|
captureStart = captureEnd = state.position;
|
|
while ((ch = state.input.charCodeAt(state.position)) !== 0) {
|
|
if (ch === 34) {
|
|
captureSegment(state, captureStart, state.position, true);
|
|
state.position++;
|
|
return true;
|
|
} else if (ch === 92) {
|
|
captureSegment(state, captureStart, state.position, true);
|
|
ch = state.input.charCodeAt(++state.position);
|
|
if (is_EOL(ch)) {
|
|
skipSeparationSpace(state, false, nodeIndent);
|
|
} else if (ch < 256 && simpleEscapeCheck[ch]) {
|
|
state.result += simpleEscapeMap[ch];
|
|
state.position++;
|
|
} else if ((tmp = escapedHexLen(ch)) > 0) {
|
|
hexLength = tmp;
|
|
hexResult = 0;
|
|
for (; hexLength > 0; hexLength--) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
if ((tmp = fromHexCode(ch)) >= 0) {
|
|
hexResult = (hexResult << 4) + tmp;
|
|
} else {
|
|
throwError(state, "expected hexadecimal character");
|
|
}
|
|
}
|
|
state.result += charFromCodepoint(hexResult);
|
|
state.position++;
|
|
} else {
|
|
throwError(state, "unknown escape sequence");
|
|
}
|
|
captureStart = captureEnd = state.position;
|
|
} else if (is_EOL(ch)) {
|
|
captureSegment(state, captureStart, captureEnd, true);
|
|
writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
|
|
captureStart = captureEnd = state.position;
|
|
} else if (state.position === state.lineStart && testDocumentSeparator(state)) {
|
|
throwError(state, "unexpected end of the document within a double quoted scalar");
|
|
} else {
|
|
state.position++;
|
|
captureEnd = state.position;
|
|
}
|
|
}
|
|
throwError(state, "unexpected end of the stream within a double quoted scalar");
|
|
}
|
|
function readFlowCollection(state, nodeIndent) {
|
|
var readNext = true, _line, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = {}, keyNode, keyTag, valueNode, ch;
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (ch === 91) {
|
|
terminator = 93;
|
|
isMapping = false;
|
|
_result = [];
|
|
} else if (ch === 123) {
|
|
terminator = 125;
|
|
isMapping = true;
|
|
_result = {};
|
|
} else {
|
|
return false;
|
|
}
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = _result;
|
|
}
|
|
ch = state.input.charCodeAt(++state.position);
|
|
while (ch !== 0) {
|
|
skipSeparationSpace(state, true, nodeIndent);
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (ch === terminator) {
|
|
state.position++;
|
|
state.tag = _tag;
|
|
state.anchor = _anchor;
|
|
state.kind = isMapping ? "mapping" : "sequence";
|
|
state.result = _result;
|
|
return true;
|
|
} else if (!readNext) {
|
|
throwError(state, "missed comma between flow collection entries");
|
|
}
|
|
keyTag = keyNode = valueNode = null;
|
|
isPair = isExplicitPair = false;
|
|
if (ch === 63) {
|
|
following = state.input.charCodeAt(state.position + 1);
|
|
if (is_WS_OR_EOL(following)) {
|
|
isPair = isExplicitPair = true;
|
|
state.position++;
|
|
skipSeparationSpace(state, true, nodeIndent);
|
|
}
|
|
}
|
|
_line = state.line;
|
|
composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
|
|
keyTag = state.tag;
|
|
keyNode = state.result;
|
|
skipSeparationSpace(state, true, nodeIndent);
|
|
ch = state.input.charCodeAt(state.position);
|
|
if ((isExplicitPair || state.line === _line) && ch === 58) {
|
|
isPair = true;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
skipSeparationSpace(state, true, nodeIndent);
|
|
composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
|
|
valueNode = state.result;
|
|
}
|
|
if (isMapping) {
|
|
storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);
|
|
} else if (isPair) {
|
|
_result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));
|
|
} else {
|
|
_result.push(keyNode);
|
|
}
|
|
skipSeparationSpace(state, true, nodeIndent);
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (ch === 44) {
|
|
readNext = true;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} else {
|
|
readNext = false;
|
|
}
|
|
}
|
|
throwError(state, "unexpected end of the stream within a flow collection");
|
|
}
|
|
function readBlockScalar(state, nodeIndent) {
|
|
var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch;
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (ch === 124) {
|
|
folding = false;
|
|
} else if (ch === 62) {
|
|
folding = true;
|
|
} else {
|
|
return false;
|
|
}
|
|
state.kind = "scalar";
|
|
state.result = "";
|
|
while (ch !== 0) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
if (ch === 43 || ch === 45) {
|
|
if (CHOMPING_CLIP === chomping) {
|
|
chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
|
|
} else {
|
|
throwError(state, "repeat of a chomping mode identifier");
|
|
}
|
|
} else if ((tmp = fromDecimalCode(ch)) >= 0) {
|
|
if (tmp === 0) {
|
|
throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
|
|
} else if (!detectedIndent) {
|
|
textIndent = nodeIndent + tmp - 1;
|
|
detectedIndent = true;
|
|
} else {
|
|
throwError(state, "repeat of an indentation width identifier");
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (is_WHITE_SPACE(ch)) {
|
|
do {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} while (is_WHITE_SPACE(ch));
|
|
if (ch === 35) {
|
|
do {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} while (!is_EOL(ch) && ch !== 0);
|
|
}
|
|
}
|
|
while (ch !== 0) {
|
|
readLineBreak(state);
|
|
state.lineIndent = 0;
|
|
ch = state.input.charCodeAt(state.position);
|
|
while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
|
|
state.lineIndent++;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
if (!detectedIndent && state.lineIndent > textIndent) {
|
|
textIndent = state.lineIndent;
|
|
}
|
|
if (is_EOL(ch)) {
|
|
emptyLines++;
|
|
continue;
|
|
}
|
|
if (state.lineIndent < textIndent) {
|
|
if (chomping === CHOMPING_KEEP) {
|
|
state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
|
|
} else if (chomping === CHOMPING_CLIP) {
|
|
if (didReadContent) {
|
|
state.result += "\n";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (folding) {
|
|
if (is_WHITE_SPACE(ch)) {
|
|
atMoreIndented = true;
|
|
state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
|
|
} else if (atMoreIndented) {
|
|
atMoreIndented = false;
|
|
state.result += common.repeat("\n", emptyLines + 1);
|
|
} else if (emptyLines === 0) {
|
|
if (didReadContent) {
|
|
state.result += " ";
|
|
}
|
|
} else {
|
|
state.result += common.repeat("\n", emptyLines);
|
|
}
|
|
} else {
|
|
state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
|
|
}
|
|
didReadContent = true;
|
|
detectedIndent = true;
|
|
emptyLines = 0;
|
|
captureStart = state.position;
|
|
while (!is_EOL(ch) && ch !== 0) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
captureSegment(state, captureStart, state.position, false);
|
|
}
|
|
return true;
|
|
}
|
|
function readBlockSequence(state, nodeIndent) {
|
|
var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch;
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = _result;
|
|
}
|
|
ch = state.input.charCodeAt(state.position);
|
|
while (ch !== 0) {
|
|
if (ch !== 45) {
|
|
break;
|
|
}
|
|
following = state.input.charCodeAt(state.position + 1);
|
|
if (!is_WS_OR_EOL(following)) {
|
|
break;
|
|
}
|
|
detected = true;
|
|
state.position++;
|
|
if (skipSeparationSpace(state, true, -1)) {
|
|
if (state.lineIndent <= nodeIndent) {
|
|
_result.push(null);
|
|
ch = state.input.charCodeAt(state.position);
|
|
continue;
|
|
}
|
|
}
|
|
_line = state.line;
|
|
composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
|
|
_result.push(state.result);
|
|
skipSeparationSpace(state, true, -1);
|
|
ch = state.input.charCodeAt(state.position);
|
|
if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
|
|
throwError(state, "bad indentation of a sequence entry");
|
|
} else if (state.lineIndent < nodeIndent) {
|
|
break;
|
|
}
|
|
}
|
|
if (detected) {
|
|
state.tag = _tag;
|
|
state.anchor = _anchor;
|
|
state.kind = "sequence";
|
|
state.result = _result;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function readBlockMapping(state, nodeIndent, flowIndent) {
|
|
var following, allowCompact, _line, _pos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = {}, keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch;
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = _result;
|
|
}
|
|
ch = state.input.charCodeAt(state.position);
|
|
while (ch !== 0) {
|
|
following = state.input.charCodeAt(state.position + 1);
|
|
_line = state.line;
|
|
_pos = state.position;
|
|
if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) {
|
|
if (ch === 63) {
|
|
if (atExplicitKey) {
|
|
storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
|
|
keyTag = keyNode = valueNode = null;
|
|
}
|
|
detected = true;
|
|
atExplicitKey = true;
|
|
allowCompact = true;
|
|
} else if (atExplicitKey) {
|
|
atExplicitKey = false;
|
|
allowCompact = true;
|
|
} else {
|
|
throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
|
|
}
|
|
state.position += 1;
|
|
ch = following;
|
|
} else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
|
|
if (state.line === _line) {
|
|
ch = state.input.charCodeAt(state.position);
|
|
while (is_WHITE_SPACE(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
if (ch === 58) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
if (!is_WS_OR_EOL(ch)) {
|
|
throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
|
|
}
|
|
if (atExplicitKey) {
|
|
storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
|
|
keyTag = keyNode = valueNode = null;
|
|
}
|
|
detected = true;
|
|
atExplicitKey = false;
|
|
allowCompact = false;
|
|
keyTag = state.tag;
|
|
keyNode = state.result;
|
|
} else if (detected) {
|
|
throwError(state, "can not read an implicit mapping pair; a colon is missed");
|
|
} else {
|
|
state.tag = _tag;
|
|
state.anchor = _anchor;
|
|
return true;
|
|
}
|
|
} else if (detected) {
|
|
throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
|
|
} else {
|
|
state.tag = _tag;
|
|
state.anchor = _anchor;
|
|
return true;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
if (state.line === _line || state.lineIndent > nodeIndent) {
|
|
if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
|
|
if (atExplicitKey) {
|
|
keyNode = state.result;
|
|
} else {
|
|
valueNode = state.result;
|
|
}
|
|
}
|
|
if (!atExplicitKey) {
|
|
storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);
|
|
keyTag = keyNode = valueNode = null;
|
|
}
|
|
skipSeparationSpace(state, true, -1);
|
|
ch = state.input.charCodeAt(state.position);
|
|
}
|
|
if (state.lineIndent > nodeIndent && ch !== 0) {
|
|
throwError(state, "bad indentation of a mapping entry");
|
|
} else if (state.lineIndent < nodeIndent) {
|
|
break;
|
|
}
|
|
}
|
|
if (atExplicitKey) {
|
|
storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
|
|
}
|
|
if (detected) {
|
|
state.tag = _tag;
|
|
state.anchor = _anchor;
|
|
state.kind = "mapping";
|
|
state.result = _result;
|
|
}
|
|
return detected;
|
|
}
|
|
function readTagProperty(state) {
|
|
var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch;
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (ch !== 33) return false;
|
|
if (state.tag !== null) {
|
|
throwError(state, "duplication of a tag property");
|
|
}
|
|
ch = state.input.charCodeAt(++state.position);
|
|
if (ch === 60) {
|
|
isVerbatim = true;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} else if (ch === 33) {
|
|
isNamed = true;
|
|
tagHandle = "!!";
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} else {
|
|
tagHandle = "!";
|
|
}
|
|
_position = state.position;
|
|
if (isVerbatim) {
|
|
do {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} while (ch !== 0 && ch !== 62);
|
|
if (state.position < state.length) {
|
|
tagName = state.input.slice(_position, state.position);
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} else {
|
|
throwError(state, "unexpected end of the stream within a verbatim tag");
|
|
}
|
|
} else {
|
|
while (ch !== 0 && !is_WS_OR_EOL(ch)) {
|
|
if (ch === 33) {
|
|
if (!isNamed) {
|
|
tagHandle = state.input.slice(_position - 1, state.position + 1);
|
|
if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
|
|
throwError(state, "named tag handle cannot contain such characters");
|
|
}
|
|
isNamed = true;
|
|
_position = state.position + 1;
|
|
} else {
|
|
throwError(state, "tag suffix cannot contain exclamation marks");
|
|
}
|
|
}
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
tagName = state.input.slice(_position, state.position);
|
|
if (PATTERN_FLOW_INDICATORS.test(tagName)) {
|
|
throwError(state, "tag suffix cannot contain flow indicator characters");
|
|
}
|
|
}
|
|
if (tagName && !PATTERN_TAG_URI.test(tagName)) {
|
|
throwError(state, "tag name cannot contain such characters: " + tagName);
|
|
}
|
|
if (isVerbatim) {
|
|
state.tag = tagName;
|
|
} else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
|
|
state.tag = state.tagMap[tagHandle] + tagName;
|
|
} else if (tagHandle === "!") {
|
|
state.tag = "!" + tagName;
|
|
} else if (tagHandle === "!!") {
|
|
state.tag = "tag:yaml.org,2002:" + tagName;
|
|
} else {
|
|
throwError(state, 'undeclared tag handle "' + tagHandle + '"');
|
|
}
|
|
return true;
|
|
}
|
|
function readAnchorProperty(state) {
|
|
var _position, ch;
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (ch !== 38) return false;
|
|
if (state.anchor !== null) {
|
|
throwError(state, "duplication of an anchor property");
|
|
}
|
|
ch = state.input.charCodeAt(++state.position);
|
|
_position = state.position;
|
|
while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
if (state.position === _position) {
|
|
throwError(state, "name of an anchor node must contain at least one character");
|
|
}
|
|
state.anchor = state.input.slice(_position, state.position);
|
|
return true;
|
|
}
|
|
function readAlias(state) {
|
|
var _position, alias, ch;
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (ch !== 42) return false;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
_position = state.position;
|
|
while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
if (state.position === _position) {
|
|
throwError(state, "name of an alias node must contain at least one character");
|
|
}
|
|
alias = state.input.slice(_position, state.position);
|
|
if (!_hasOwnProperty.call(state.anchorMap, alias)) {
|
|
throwError(state, 'unidentified alias "' + alias + '"');
|
|
}
|
|
state.result = state.anchorMap[alias];
|
|
skipSeparationSpace(state, true, -1);
|
|
return true;
|
|
}
|
|
function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
|
|
var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, type, flowIndent, blockIndent;
|
|
if (state.listener !== null) {
|
|
state.listener("open", state);
|
|
}
|
|
state.tag = null;
|
|
state.anchor = null;
|
|
state.kind = null;
|
|
state.result = null;
|
|
allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
|
|
if (allowToSeek) {
|
|
if (skipSeparationSpace(state, true, -1)) {
|
|
atNewLine = true;
|
|
if (state.lineIndent > parentIndent) {
|
|
indentStatus = 1;
|
|
} else if (state.lineIndent === parentIndent) {
|
|
indentStatus = 0;
|
|
} else if (state.lineIndent < parentIndent) {
|
|
indentStatus = -1;
|
|
}
|
|
}
|
|
}
|
|
if (indentStatus === 1) {
|
|
while (readTagProperty(state) || readAnchorProperty(state)) {
|
|
if (skipSeparationSpace(state, true, -1)) {
|
|
atNewLine = true;
|
|
allowBlockCollections = allowBlockStyles;
|
|
if (state.lineIndent > parentIndent) {
|
|
indentStatus = 1;
|
|
} else if (state.lineIndent === parentIndent) {
|
|
indentStatus = 0;
|
|
} else if (state.lineIndent < parentIndent) {
|
|
indentStatus = -1;
|
|
}
|
|
} else {
|
|
allowBlockCollections = false;
|
|
}
|
|
}
|
|
}
|
|
if (allowBlockCollections) {
|
|
allowBlockCollections = atNewLine || allowCompact;
|
|
}
|
|
if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
|
|
if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
|
|
flowIndent = parentIndent;
|
|
} else {
|
|
flowIndent = parentIndent + 1;
|
|
}
|
|
blockIndent = state.position - state.lineStart;
|
|
if (indentStatus === 1) {
|
|
if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) {
|
|
hasContent = true;
|
|
} else {
|
|
if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) {
|
|
hasContent = true;
|
|
} else if (readAlias(state)) {
|
|
hasContent = true;
|
|
if (state.tag !== null || state.anchor !== null) {
|
|
throwError(state, "alias node should not have any properties");
|
|
}
|
|
} else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
|
|
hasContent = true;
|
|
if (state.tag === null) {
|
|
state.tag = "?";
|
|
}
|
|
}
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = state.result;
|
|
}
|
|
}
|
|
} else if (indentStatus === 0) {
|
|
hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
|
|
}
|
|
}
|
|
if (state.tag !== null && state.tag !== "!") {
|
|
if (state.tag === "?") {
|
|
if (state.result !== null && state.kind !== "scalar") {
|
|
throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
|
|
}
|
|
for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
|
|
type = state.implicitTypes[typeIndex];
|
|
if (type.resolve(state.result)) {
|
|
state.result = type.construct(state.result);
|
|
state.tag = type.tag;
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = state.result;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} else if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) {
|
|
type = state.typeMap[state.kind || "fallback"][state.tag];
|
|
if (state.result !== null && type.kind !== state.kind) {
|
|
throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
|
|
}
|
|
if (!type.resolve(state.result)) {
|
|
throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
|
|
} else {
|
|
state.result = type.construct(state.result);
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = state.result;
|
|
}
|
|
}
|
|
} else {
|
|
throwError(state, "unknown tag !<" + state.tag + ">");
|
|
}
|
|
}
|
|
if (state.listener !== null) {
|
|
state.listener("close", state);
|
|
}
|
|
return state.tag !== null || state.anchor !== null || hasContent;
|
|
}
|
|
function readDocument(state) {
|
|
var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch;
|
|
state.version = null;
|
|
state.checkLineBreaks = state.legacy;
|
|
state.tagMap = {};
|
|
state.anchorMap = {};
|
|
while ((ch = state.input.charCodeAt(state.position)) !== 0) {
|
|
skipSeparationSpace(state, true, -1);
|
|
ch = state.input.charCodeAt(state.position);
|
|
if (state.lineIndent > 0 || ch !== 37) {
|
|
break;
|
|
}
|
|
hasDirectives = true;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
_position = state.position;
|
|
while (ch !== 0 && !is_WS_OR_EOL(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
directiveName = state.input.slice(_position, state.position);
|
|
directiveArgs = [];
|
|
if (directiveName.length < 1) {
|
|
throwError(state, "directive name must not be less than one character in length");
|
|
}
|
|
while (ch !== 0) {
|
|
while (is_WHITE_SPACE(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
if (ch === 35) {
|
|
do {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} while (ch !== 0 && !is_EOL(ch));
|
|
break;
|
|
}
|
|
if (is_EOL(ch)) break;
|
|
_position = state.position;
|
|
while (ch !== 0 && !is_WS_OR_EOL(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
directiveArgs.push(state.input.slice(_position, state.position));
|
|
}
|
|
if (ch !== 0) readLineBreak(state);
|
|
if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
|
|
directiveHandlers[directiveName](state, directiveName, directiveArgs);
|
|
} else {
|
|
throwWarning(state, 'unknown document directive "' + directiveName + '"');
|
|
}
|
|
}
|
|
skipSeparationSpace(state, true, -1);
|
|
if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
|
|
state.position += 3;
|
|
skipSeparationSpace(state, true, -1);
|
|
} else if (hasDirectives) {
|
|
throwError(state, "directives end mark is expected");
|
|
}
|
|
composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
|
|
skipSeparationSpace(state, true, -1);
|
|
if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
|
|
throwWarning(state, "non-ASCII line breaks are interpreted as content");
|
|
}
|
|
state.documents.push(state.result);
|
|
if (state.position === state.lineStart && testDocumentSeparator(state)) {
|
|
if (state.input.charCodeAt(state.position) === 46) {
|
|
state.position += 3;
|
|
skipSeparationSpace(state, true, -1);
|
|
}
|
|
return;
|
|
}
|
|
if (state.position < state.length - 1) {
|
|
throwError(state, "end of the stream or a document separator is expected");
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
function loadDocuments(input, options2) {
|
|
input = String(input);
|
|
options2 = options2 || {};
|
|
if (input.length !== 0) {
|
|
if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) {
|
|
input += "\n";
|
|
}
|
|
if (input.charCodeAt(0) === 65279) {
|
|
input = input.slice(1);
|
|
}
|
|
}
|
|
var state = new State(input, options2);
|
|
var nullpos = input.indexOf("\0");
|
|
if (nullpos !== -1) {
|
|
state.position = nullpos;
|
|
throwError(state, "null byte is not allowed in input");
|
|
}
|
|
state.input += "\0";
|
|
while (state.input.charCodeAt(state.position) === 32) {
|
|
state.lineIndent += 1;
|
|
state.position += 1;
|
|
}
|
|
while (state.position < state.length - 1) {
|
|
readDocument(state);
|
|
}
|
|
return state.documents;
|
|
}
|
|
function loadAll(input, iterator, options2) {
|
|
if (iterator !== null && typeof iterator === "object" && typeof options2 === "undefined") {
|
|
options2 = iterator;
|
|
iterator = null;
|
|
}
|
|
var documents = loadDocuments(input, options2);
|
|
if (typeof iterator !== "function") {
|
|
return documents;
|
|
}
|
|
for (var index = 0, length = documents.length; index < length; index += 1) {
|
|
iterator(documents[index]);
|
|
}
|
|
}
|
|
function load(input, options2) {
|
|
var documents = loadDocuments(input, options2);
|
|
if (documents.length === 0) {
|
|
return void 0;
|
|
} else if (documents.length === 1) {
|
|
return documents[0];
|
|
}
|
|
throw new YAMLException("expected a single document in the stream, but found more");
|
|
}
|
|
function safeLoadAll(input, iterator, options2) {
|
|
if (typeof iterator === "object" && iterator !== null && typeof options2 === "undefined") {
|
|
options2 = iterator;
|
|
iterator = null;
|
|
}
|
|
return loadAll(input, iterator, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options2));
|
|
}
|
|
function safeLoad(input, options2) {
|
|
return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options2));
|
|
}
|
|
module2.exports.loadAll = loadAll;
|
|
module2.exports.load = load;
|
|
module2.exports.safeLoadAll = safeLoadAll;
|
|
module2.exports.safeLoad = safeLoad;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/dumper.js
|
|
var require_dumper = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml/dumper.js"(exports2, module2) {
|
|
"use strict";
|
|
var common = require_common();
|
|
var YAMLException = require_exception();
|
|
var DEFAULT_FULL_SCHEMA = require_default_full();
|
|
var DEFAULT_SAFE_SCHEMA = require_default_safe();
|
|
var _toString = Object.prototype.toString;
|
|
var _hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
var CHAR_TAB = 9;
|
|
var CHAR_LINE_FEED = 10;
|
|
var CHAR_CARRIAGE_RETURN = 13;
|
|
var CHAR_SPACE = 32;
|
|
var CHAR_EXCLAMATION = 33;
|
|
var CHAR_DOUBLE_QUOTE = 34;
|
|
var CHAR_SHARP = 35;
|
|
var CHAR_PERCENT = 37;
|
|
var CHAR_AMPERSAND = 38;
|
|
var CHAR_SINGLE_QUOTE = 39;
|
|
var CHAR_ASTERISK = 42;
|
|
var CHAR_COMMA = 44;
|
|
var CHAR_MINUS = 45;
|
|
var CHAR_COLON = 58;
|
|
var CHAR_EQUALS = 61;
|
|
var CHAR_GREATER_THAN = 62;
|
|
var CHAR_QUESTION = 63;
|
|
var CHAR_COMMERCIAL_AT = 64;
|
|
var CHAR_LEFT_SQUARE_BRACKET = 91;
|
|
var CHAR_RIGHT_SQUARE_BRACKET = 93;
|
|
var CHAR_GRAVE_ACCENT = 96;
|
|
var CHAR_LEFT_CURLY_BRACKET = 123;
|
|
var CHAR_VERTICAL_LINE = 124;
|
|
var CHAR_RIGHT_CURLY_BRACKET = 125;
|
|
var ESCAPE_SEQUENCES = {};
|
|
ESCAPE_SEQUENCES[0] = "\\0";
|
|
ESCAPE_SEQUENCES[7] = "\\a";
|
|
ESCAPE_SEQUENCES[8] = "\\b";
|
|
ESCAPE_SEQUENCES[9] = "\\t";
|
|
ESCAPE_SEQUENCES[10] = "\\n";
|
|
ESCAPE_SEQUENCES[11] = "\\v";
|
|
ESCAPE_SEQUENCES[12] = "\\f";
|
|
ESCAPE_SEQUENCES[13] = "\\r";
|
|
ESCAPE_SEQUENCES[27] = "\\e";
|
|
ESCAPE_SEQUENCES[34] = '\\"';
|
|
ESCAPE_SEQUENCES[92] = "\\\\";
|
|
ESCAPE_SEQUENCES[133] = "\\N";
|
|
ESCAPE_SEQUENCES[160] = "\\_";
|
|
ESCAPE_SEQUENCES[8232] = "\\L";
|
|
ESCAPE_SEQUENCES[8233] = "\\P";
|
|
var DEPRECATED_BOOLEANS_SYNTAX = [
|
|
"y",
|
|
"Y",
|
|
"yes",
|
|
"Yes",
|
|
"YES",
|
|
"on",
|
|
"On",
|
|
"ON",
|
|
"n",
|
|
"N",
|
|
"no",
|
|
"No",
|
|
"NO",
|
|
"off",
|
|
"Off",
|
|
"OFF"
|
|
];
|
|
function compileStyleMap(schema, map) {
|
|
var result, keys, index, length, tag, style, type;
|
|
if (map === null) return {};
|
|
result = {};
|
|
keys = Object.keys(map);
|
|
for (index = 0, length = keys.length; index < length; index += 1) {
|
|
tag = keys[index];
|
|
style = String(map[tag]);
|
|
if (tag.slice(0, 2) === "!!") {
|
|
tag = "tag:yaml.org,2002:" + tag.slice(2);
|
|
}
|
|
type = schema.compiledTypeMap["fallback"][tag];
|
|
if (type && _hasOwnProperty.call(type.styleAliases, style)) {
|
|
style = type.styleAliases[style];
|
|
}
|
|
result[tag] = style;
|
|
}
|
|
return result;
|
|
}
|
|
function encodeHex(character) {
|
|
var string, handle, length;
|
|
string = character.toString(16).toUpperCase();
|
|
if (character <= 255) {
|
|
handle = "x";
|
|
length = 2;
|
|
} else if (character <= 65535) {
|
|
handle = "u";
|
|
length = 4;
|
|
} else if (character <= 4294967295) {
|
|
handle = "U";
|
|
length = 8;
|
|
} else {
|
|
throw new YAMLException("code point within a string may not be greater than 0xFFFFFFFF");
|
|
}
|
|
return "\\" + handle + common.repeat("0", length - string.length) + string;
|
|
}
|
|
function State(options2) {
|
|
this.schema = options2["schema"] || DEFAULT_FULL_SCHEMA;
|
|
this.indent = Math.max(1, options2["indent"] || 2);
|
|
this.noArrayIndent = options2["noArrayIndent"] || false;
|
|
this.skipInvalid = options2["skipInvalid"] || false;
|
|
this.flowLevel = common.isNothing(options2["flowLevel"]) ? -1 : options2["flowLevel"];
|
|
this.styleMap = compileStyleMap(this.schema, options2["styles"] || null);
|
|
this.sortKeys = options2["sortKeys"] || false;
|
|
this.lineWidth = options2["lineWidth"] || 80;
|
|
this.noRefs = options2["noRefs"] || false;
|
|
this.noCompatMode = options2["noCompatMode"] || false;
|
|
this.condenseFlow = options2["condenseFlow"] || false;
|
|
this.implicitTypes = this.schema.compiledImplicit;
|
|
this.explicitTypes = this.schema.compiledExplicit;
|
|
this.tag = null;
|
|
this.result = "";
|
|
this.duplicates = [];
|
|
this.usedDuplicates = null;
|
|
}
|
|
function indentString(string, spaces) {
|
|
var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string.length;
|
|
while (position < length) {
|
|
next = string.indexOf("\n", position);
|
|
if (next === -1) {
|
|
line = string.slice(position);
|
|
position = length;
|
|
} else {
|
|
line = string.slice(position, next + 1);
|
|
position = next + 1;
|
|
}
|
|
if (line.length && line !== "\n") result += ind;
|
|
result += line;
|
|
}
|
|
return result;
|
|
}
|
|
function generateNextLine(state, level) {
|
|
return "\n" + common.repeat(" ", state.indent * level);
|
|
}
|
|
function testImplicitResolving(state, str2) {
|
|
var index, length, type;
|
|
for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
|
|
type = state.implicitTypes[index];
|
|
if (type.resolve(str2)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isWhitespace(c) {
|
|
return c === CHAR_SPACE || c === CHAR_TAB;
|
|
}
|
|
function isPrintable(c) {
|
|
return 32 <= c && c <= 126 || 161 <= c && c <= 55295 && c !== 8232 && c !== 8233 || 57344 <= c && c <= 65533 && c !== 65279 || 65536 <= c && c <= 1114111;
|
|
}
|
|
function isNsChar(c) {
|
|
return isPrintable(c) && !isWhitespace(c) && c !== 65279 && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
|
|
}
|
|
function isPlainSafe(c, prev) {
|
|
return isPrintable(c) && c !== 65279 && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_COLON && (c !== CHAR_SHARP || prev && isNsChar(prev));
|
|
}
|
|
function isPlainSafeFirst(c) {
|
|
return isPrintable(c) && c !== 65279 && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
|
|
}
|
|
function needIndentIndicator(string) {
|
|
var leadingSpaceRe = /^\n* /;
|
|
return leadingSpaceRe.test(string);
|
|
}
|
|
var STYLE_PLAIN = 1;
|
|
var STYLE_SINGLE = 2;
|
|
var STYLE_LITERAL = 3;
|
|
var STYLE_FOLDED = 4;
|
|
var STYLE_DOUBLE = 5;
|
|
function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {
|
|
var i;
|
|
var char, prev_char;
|
|
var hasLineBreak = false;
|
|
var hasFoldableLine = false;
|
|
var shouldTrackWidth = lineWidth !== -1;
|
|
var previousLineBreak = -1;
|
|
var plain = isPlainSafeFirst(string.charCodeAt(0)) && !isWhitespace(string.charCodeAt(string.length - 1));
|
|
if (singleLineOnly) {
|
|
for (i = 0; i < string.length; i++) {
|
|
char = string.charCodeAt(i);
|
|
if (!isPrintable(char)) {
|
|
return STYLE_DOUBLE;
|
|
}
|
|
prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
|
|
plain = plain && isPlainSafe(char, prev_char);
|
|
}
|
|
} else {
|
|
for (i = 0; i < string.length; i++) {
|
|
char = string.charCodeAt(i);
|
|
if (char === CHAR_LINE_FEED) {
|
|
hasLineBreak = true;
|
|
if (shouldTrackWidth) {
|
|
hasFoldableLine = hasFoldableLine || // Foldable line = too long, and not more-indented.
|
|
i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
|
|
previousLineBreak = i;
|
|
}
|
|
} else if (!isPrintable(char)) {
|
|
return STYLE_DOUBLE;
|
|
}
|
|
prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
|
|
plain = plain && isPlainSafe(char, prev_char);
|
|
}
|
|
hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ");
|
|
}
|
|
if (!hasLineBreak && !hasFoldableLine) {
|
|
return plain && !testAmbiguousType(string) ? STYLE_PLAIN : STYLE_SINGLE;
|
|
}
|
|
if (indentPerLevel > 9 && needIndentIndicator(string)) {
|
|
return STYLE_DOUBLE;
|
|
}
|
|
return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
|
|
}
|
|
function writeScalar(state, string, level, iskey) {
|
|
state.dump = (function() {
|
|
if (string.length === 0) {
|
|
return "''";
|
|
}
|
|
if (!state.noCompatMode && DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {
|
|
return "'" + string + "'";
|
|
}
|
|
var indent = state.indent * Math.max(1, level);
|
|
var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
|
|
var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
|
|
function testAmbiguity(string2) {
|
|
return testImplicitResolving(state, string2);
|
|
}
|
|
switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
|
|
case STYLE_PLAIN:
|
|
return string;
|
|
case STYLE_SINGLE:
|
|
return "'" + string.replace(/'/g, "''") + "'";
|
|
case STYLE_LITERAL:
|
|
return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
|
|
case STYLE_FOLDED:
|
|
return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
|
|
case STYLE_DOUBLE:
|
|
return '"' + escapeString(string, lineWidth) + '"';
|
|
default:
|
|
throw new YAMLException("impossible error: invalid scalar style");
|
|
}
|
|
})();
|
|
}
|
|
function blockHeader(string, indentPerLevel) {
|
|
var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
|
|
var clip = string[string.length - 1] === "\n";
|
|
var keep = clip && (string[string.length - 2] === "\n" || string === "\n");
|
|
var chomp = keep ? "+" : clip ? "" : "-";
|
|
return indentIndicator + chomp + "\n";
|
|
}
|
|
function dropEndingNewline(string) {
|
|
return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
|
|
}
|
|
function foldString(string, width) {
|
|
var lineRe = /(\n+)([^\n]*)/g;
|
|
var result = (function() {
|
|
var nextLF = string.indexOf("\n");
|
|
nextLF = nextLF !== -1 ? nextLF : string.length;
|
|
lineRe.lastIndex = nextLF;
|
|
return foldLine(string.slice(0, nextLF), width);
|
|
})();
|
|
var prevMoreIndented = string[0] === "\n" || string[0] === " ";
|
|
var moreIndented;
|
|
var match;
|
|
while (match = lineRe.exec(string)) {
|
|
var prefix = match[1], line = match[2];
|
|
moreIndented = line[0] === " ";
|
|
result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
|
|
prevMoreIndented = moreIndented;
|
|
}
|
|
return result;
|
|
}
|
|
function foldLine(line, width) {
|
|
if (line === "" || line[0] === " ") return line;
|
|
var breakRe = / [^ ]/g;
|
|
var match;
|
|
var start = 0, end, curr = 0, next = 0;
|
|
var result = "";
|
|
while (match = breakRe.exec(line)) {
|
|
next = match.index;
|
|
if (next - start > width) {
|
|
end = curr > start ? curr : next;
|
|
result += "\n" + line.slice(start, end);
|
|
start = end + 1;
|
|
}
|
|
curr = next;
|
|
}
|
|
result += "\n";
|
|
if (line.length - start > width && curr > start) {
|
|
result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
|
|
} else {
|
|
result += line.slice(start);
|
|
}
|
|
return result.slice(1);
|
|
}
|
|
function escapeString(string) {
|
|
var result = "";
|
|
var char, nextChar;
|
|
var escapeSeq;
|
|
for (var i = 0; i < string.length; i++) {
|
|
char = string.charCodeAt(i);
|
|
if (char >= 55296 && char <= 56319) {
|
|
nextChar = string.charCodeAt(i + 1);
|
|
if (nextChar >= 56320 && nextChar <= 57343) {
|
|
result += encodeHex((char - 55296) * 1024 + nextChar - 56320 + 65536);
|
|
i++;
|
|
continue;
|
|
}
|
|
}
|
|
escapeSeq = ESCAPE_SEQUENCES[char];
|
|
result += !escapeSeq && isPrintable(char) ? string[i] : escapeSeq || encodeHex(char);
|
|
}
|
|
return result;
|
|
}
|
|
function writeFlowSequence(state, level, object) {
|
|
var _result = "", _tag = state.tag, index, length;
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
if (writeNode(state, level, object[index], false, false)) {
|
|
if (index !== 0) _result += "," + (!state.condenseFlow ? " " : "");
|
|
_result += state.dump;
|
|
}
|
|
}
|
|
state.tag = _tag;
|
|
state.dump = "[" + _result + "]";
|
|
}
|
|
function writeBlockSequence(state, level, object, compact) {
|
|
var _result = "", _tag = state.tag, index, length;
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
if (writeNode(state, level + 1, object[index], true, true)) {
|
|
if (!compact || index !== 0) {
|
|
_result += generateNextLine(state, level);
|
|
}
|
|
if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
|
|
_result += "-";
|
|
} else {
|
|
_result += "- ";
|
|
}
|
|
_result += state.dump;
|
|
}
|
|
}
|
|
state.tag = _tag;
|
|
state.dump = _result || "[]";
|
|
}
|
|
function writeFlowMapping(state, level, object) {
|
|
var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, pairBuffer;
|
|
for (index = 0, length = objectKeyList.length; index < length; index += 1) {
|
|
pairBuffer = "";
|
|
if (index !== 0) pairBuffer += ", ";
|
|
if (state.condenseFlow) pairBuffer += '"';
|
|
objectKey = objectKeyList[index];
|
|
objectValue = object[objectKey];
|
|
if (!writeNode(state, level, objectKey, false, false)) {
|
|
continue;
|
|
}
|
|
if (state.dump.length > 1024) pairBuffer += "? ";
|
|
pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
|
|
if (!writeNode(state, level, objectValue, false, false)) {
|
|
continue;
|
|
}
|
|
pairBuffer += state.dump;
|
|
_result += pairBuffer;
|
|
}
|
|
state.tag = _tag;
|
|
state.dump = "{" + _result + "}";
|
|
}
|
|
function writeBlockMapping(state, level, object, compact) {
|
|
var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
|
|
if (state.sortKeys === true) {
|
|
objectKeyList.sort();
|
|
} else if (typeof state.sortKeys === "function") {
|
|
objectKeyList.sort(state.sortKeys);
|
|
} else if (state.sortKeys) {
|
|
throw new YAMLException("sortKeys must be a boolean or a function");
|
|
}
|
|
for (index = 0, length = objectKeyList.length; index < length; index += 1) {
|
|
pairBuffer = "";
|
|
if (!compact || index !== 0) {
|
|
pairBuffer += generateNextLine(state, level);
|
|
}
|
|
objectKey = objectKeyList[index];
|
|
objectValue = object[objectKey];
|
|
if (!writeNode(state, level + 1, objectKey, true, true, true)) {
|
|
continue;
|
|
}
|
|
explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
|
|
if (explicitPair) {
|
|
if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
|
|
pairBuffer += "?";
|
|
} else {
|
|
pairBuffer += "? ";
|
|
}
|
|
}
|
|
pairBuffer += state.dump;
|
|
if (explicitPair) {
|
|
pairBuffer += generateNextLine(state, level);
|
|
}
|
|
if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
|
|
continue;
|
|
}
|
|
if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
|
|
pairBuffer += ":";
|
|
} else {
|
|
pairBuffer += ": ";
|
|
}
|
|
pairBuffer += state.dump;
|
|
_result += pairBuffer;
|
|
}
|
|
state.tag = _tag;
|
|
state.dump = _result || "{}";
|
|
}
|
|
function detectType(state, object, explicit) {
|
|
var _result, typeList, index, length, type, style;
|
|
typeList = explicit ? state.explicitTypes : state.implicitTypes;
|
|
for (index = 0, length = typeList.length; index < length; index += 1) {
|
|
type = typeList[index];
|
|
if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
|
|
state.tag = explicit ? type.tag : "?";
|
|
if (type.represent) {
|
|
style = state.styleMap[type.tag] || type.defaultStyle;
|
|
if (_toString.call(type.represent) === "[object Function]") {
|
|
_result = type.represent(object, style);
|
|
} else if (_hasOwnProperty.call(type.represent, style)) {
|
|
_result = type.represent[style](object, style);
|
|
} else {
|
|
throw new YAMLException("!<" + type.tag + '> tag resolver accepts not "' + style + '" style');
|
|
}
|
|
state.dump = _result;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function writeNode(state, level, object, block, compact, iskey) {
|
|
state.tag = null;
|
|
state.dump = object;
|
|
if (!detectType(state, object, false)) {
|
|
detectType(state, object, true);
|
|
}
|
|
var type = _toString.call(state.dump);
|
|
if (block) {
|
|
block = state.flowLevel < 0 || state.flowLevel > level;
|
|
}
|
|
var objectOrArray = type === "[object Object]" || type === "[object Array]", duplicateIndex, duplicate;
|
|
if (objectOrArray) {
|
|
duplicateIndex = state.duplicates.indexOf(object);
|
|
duplicate = duplicateIndex !== -1;
|
|
}
|
|
if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
|
|
compact = false;
|
|
}
|
|
if (duplicate && state.usedDuplicates[duplicateIndex]) {
|
|
state.dump = "*ref_" + duplicateIndex;
|
|
} else {
|
|
if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
|
|
state.usedDuplicates[duplicateIndex] = true;
|
|
}
|
|
if (type === "[object Object]") {
|
|
if (block && Object.keys(state.dump).length !== 0) {
|
|
writeBlockMapping(state, level, state.dump, compact);
|
|
if (duplicate) {
|
|
state.dump = "&ref_" + duplicateIndex + state.dump;
|
|
}
|
|
} else {
|
|
writeFlowMapping(state, level, state.dump);
|
|
if (duplicate) {
|
|
state.dump = "&ref_" + duplicateIndex + " " + state.dump;
|
|
}
|
|
}
|
|
} else if (type === "[object Array]") {
|
|
var arrayLevel = state.noArrayIndent && level > 0 ? level - 1 : level;
|
|
if (block && state.dump.length !== 0) {
|
|
writeBlockSequence(state, arrayLevel, state.dump, compact);
|
|
if (duplicate) {
|
|
state.dump = "&ref_" + duplicateIndex + state.dump;
|
|
}
|
|
} else {
|
|
writeFlowSequence(state, arrayLevel, state.dump);
|
|
if (duplicate) {
|
|
state.dump = "&ref_" + duplicateIndex + " " + state.dump;
|
|
}
|
|
}
|
|
} else if (type === "[object String]") {
|
|
if (state.tag !== "?") {
|
|
writeScalar(state, state.dump, level, iskey);
|
|
}
|
|
} else {
|
|
if (state.skipInvalid) return false;
|
|
throw new YAMLException("unacceptable kind of an object to dump " + type);
|
|
}
|
|
if (state.tag !== null && state.tag !== "?") {
|
|
state.dump = "!<" + state.tag + "> " + state.dump;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getDuplicateReferences(object, state) {
|
|
var objects = [], duplicatesIndexes = [], index, length;
|
|
inspectNode(object, objects, duplicatesIndexes);
|
|
for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
|
|
state.duplicates.push(objects[duplicatesIndexes[index]]);
|
|
}
|
|
state.usedDuplicates = new Array(length);
|
|
}
|
|
function inspectNode(object, objects, duplicatesIndexes) {
|
|
var objectKeyList, index, length;
|
|
if (object !== null && typeof object === "object") {
|
|
index = objects.indexOf(object);
|
|
if (index !== -1) {
|
|
if (duplicatesIndexes.indexOf(index) === -1) {
|
|
duplicatesIndexes.push(index);
|
|
}
|
|
} else {
|
|
objects.push(object);
|
|
if (Array.isArray(object)) {
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
inspectNode(object[index], objects, duplicatesIndexes);
|
|
}
|
|
} else {
|
|
objectKeyList = Object.keys(object);
|
|
for (index = 0, length = objectKeyList.length; index < length; index += 1) {
|
|
inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function dump(input, options2) {
|
|
options2 = options2 || {};
|
|
var state = new State(options2);
|
|
if (!state.noRefs) getDuplicateReferences(input, state);
|
|
if (writeNode(state, 0, input, true, true)) return state.dump + "\n";
|
|
return "";
|
|
}
|
|
function safeDump(input, options2) {
|
|
return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options2));
|
|
}
|
|
module2.exports.dump = dump;
|
|
module2.exports.safeDump = safeDump;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml.js
|
|
var require_js_yaml = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/lib/js-yaml.js"(exports2, module2) {
|
|
"use strict";
|
|
var loader = require_loader();
|
|
var dumper = require_dumper();
|
|
function deprecated(name) {
|
|
return function() {
|
|
throw new Error("Function " + name + " is deprecated and cannot be used.");
|
|
};
|
|
}
|
|
module2.exports.Type = require_type();
|
|
module2.exports.Schema = require_schema();
|
|
module2.exports.FAILSAFE_SCHEMA = require_failsafe();
|
|
module2.exports.JSON_SCHEMA = require_json();
|
|
module2.exports.CORE_SCHEMA = require_core();
|
|
module2.exports.DEFAULT_SAFE_SCHEMA = require_default_safe();
|
|
module2.exports.DEFAULT_FULL_SCHEMA = require_default_full();
|
|
module2.exports.load = loader.load;
|
|
module2.exports.loadAll = loader.loadAll;
|
|
module2.exports.safeLoad = loader.safeLoad;
|
|
module2.exports.safeLoadAll = loader.safeLoadAll;
|
|
module2.exports.dump = dumper.dump;
|
|
module2.exports.safeDump = dumper.safeDump;
|
|
module2.exports.YAMLException = require_exception();
|
|
module2.exports.MINIMAL_SCHEMA = require_failsafe();
|
|
module2.exports.SAFE_SCHEMA = require_default_safe();
|
|
module2.exports.DEFAULT_SCHEMA = require_default_full();
|
|
module2.exports.scan = deprecated("scan");
|
|
module2.exports.parse = deprecated("parse");
|
|
module2.exports.compose = deprecated("compose");
|
|
module2.exports.addConstructor = deprecated("addConstructor");
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/index.js
|
|
var require_js_yaml2 = __commonJS({
|
|
"node_modules/.pnpm/js-yaml@3.14.2/node_modules/js-yaml/index.js"(exports2, module2) {
|
|
"use strict";
|
|
var yaml2 = require_js_yaml();
|
|
module2.exports = yaml2;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines.js
|
|
var require_engines = __commonJS({
|
|
"node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engines.js"(exports, module) {
|
|
"use strict";
|
|
var yaml = require_js_yaml2();
|
|
var engines = exports = module.exports;
|
|
engines.yaml = {
|
|
parse: yaml.safeLoad.bind(yaml),
|
|
stringify: yaml.safeDump.bind(yaml)
|
|
};
|
|
engines.json = {
|
|
parse: JSON.parse.bind(JSON),
|
|
stringify: function(obj, options2) {
|
|
const opts = Object.assign({ replacer: null, space: 2 }, options2);
|
|
return JSON.stringify(obj, opts.replacer, opts.space);
|
|
}
|
|
};
|
|
engines.javascript = {
|
|
parse: function parse(str, options, wrap) {
|
|
try {
|
|
if (wrap !== false) {
|
|
str = "(function() {\nreturn " + str.trim() + ";\n}());";
|
|
}
|
|
return eval(str) || {};
|
|
} catch (err) {
|
|
if (wrap !== false && /(unexpected|identifier)/i.test(err.message)) {
|
|
return parse(str, options, false);
|
|
}
|
|
throw new SyntaxError(err);
|
|
}
|
|
},
|
|
stringify: function() {
|
|
throw new Error("stringifying JavaScript is not supported");
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/strip-bom-string@1.0.0/node_modules/strip-bom-string/index.js
|
|
var require_strip_bom_string = __commonJS({
|
|
"node_modules/.pnpm/strip-bom-string@1.0.0/node_modules/strip-bom-string/index.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = function(str2) {
|
|
if (typeof str2 === "string" && str2.charAt(0) === "\uFEFF") {
|
|
return str2.slice(1);
|
|
}
|
|
return str2;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js
|
|
var require_utils = __commonJS({
|
|
"node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/utils.js"(exports2) {
|
|
"use strict";
|
|
var stripBom = require_strip_bom_string();
|
|
var typeOf = require_kind_of();
|
|
exports2.define = function(obj, key, val) {
|
|
Reflect.defineProperty(obj, key, {
|
|
enumerable: false,
|
|
configurable: true,
|
|
writable: true,
|
|
value: val
|
|
});
|
|
};
|
|
exports2.isBuffer = function(val) {
|
|
return typeOf(val) === "buffer";
|
|
};
|
|
exports2.isObject = function(val) {
|
|
return typeOf(val) === "object";
|
|
};
|
|
exports2.toBuffer = function(input) {
|
|
return typeof input === "string" ? Buffer.from(input) : input;
|
|
};
|
|
exports2.toString = function(input) {
|
|
if (exports2.isBuffer(input)) return stripBom(String(input));
|
|
if (typeof input !== "string") {
|
|
throw new TypeError("expected input to be a string or buffer");
|
|
}
|
|
return stripBom(input);
|
|
};
|
|
exports2.arrayify = function(val) {
|
|
return val ? Array.isArray(val) ? val : [val] : [];
|
|
};
|
|
exports2.startsWith = function(str2, substr, len) {
|
|
if (typeof len !== "number") len = substr.length;
|
|
return str2.slice(0, len) === substr;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js
|
|
var require_defaults = __commonJS({
|
|
"node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/defaults.js"(exports2, module2) {
|
|
"use strict";
|
|
var engines2 = require_engines();
|
|
var utils = require_utils();
|
|
module2.exports = function(options2) {
|
|
const opts = Object.assign({}, options2);
|
|
opts.delimiters = utils.arrayify(opts.delims || opts.delimiters || "---");
|
|
if (opts.delimiters.length === 1) {
|
|
opts.delimiters.push(opts.delimiters[0]);
|
|
}
|
|
opts.language = (opts.language || opts.lang || "yaml").toLowerCase();
|
|
opts.engines = Object.assign({}, engines2, opts.parsers, opts.engines);
|
|
return opts;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engine.js
|
|
var require_engine = __commonJS({
|
|
"node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/engine.js"(exports2, module2) {
|
|
"use strict";
|
|
module2.exports = function(name, options2) {
|
|
let engine = options2.engines[name] || options2.engines[aliase(name)];
|
|
if (typeof engine === "undefined") {
|
|
throw new Error('gray-matter engine "' + name + '" is not registered');
|
|
}
|
|
if (typeof engine === "function") {
|
|
engine = { parse: engine };
|
|
}
|
|
return engine;
|
|
};
|
|
function aliase(name) {
|
|
switch (name.toLowerCase()) {
|
|
case "js":
|
|
case "javascript":
|
|
return "javascript";
|
|
case "coffee":
|
|
case "coffeescript":
|
|
case "cson":
|
|
return "coffee";
|
|
case "yaml":
|
|
case "yml":
|
|
return "yaml";
|
|
default: {
|
|
return name;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify.js
|
|
var require_stringify = __commonJS({
|
|
"node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/stringify.js"(exports2, module2) {
|
|
"use strict";
|
|
var typeOf = require_kind_of();
|
|
var getEngine = require_engine();
|
|
var defaults = require_defaults();
|
|
module2.exports = function(file, data, options2) {
|
|
if (data == null && options2 == null) {
|
|
switch (typeOf(file)) {
|
|
case "object":
|
|
data = file.data;
|
|
options2 = {};
|
|
break;
|
|
case "string":
|
|
return file;
|
|
default: {
|
|
throw new TypeError("expected file to be a string or object");
|
|
}
|
|
}
|
|
}
|
|
const str2 = file.content;
|
|
const opts = defaults(options2);
|
|
if (data == null) {
|
|
if (!opts.data) return file;
|
|
data = opts.data;
|
|
}
|
|
const language = file.language || opts.language;
|
|
const engine = getEngine(language, opts);
|
|
if (typeof engine.stringify !== "function") {
|
|
throw new TypeError('expected "' + language + '.stringify" to be a function');
|
|
}
|
|
data = Object.assign({}, file.data, data);
|
|
const open = opts.delimiters[0];
|
|
const close = opts.delimiters[1];
|
|
const matter2 = engine.stringify(data, options2).trim();
|
|
let buf = "";
|
|
if (matter2 !== "{}") {
|
|
buf = newline(open) + newline(matter2) + newline(close);
|
|
}
|
|
if (typeof file.excerpt === "string" && file.excerpt !== "") {
|
|
if (str2.indexOf(file.excerpt.trim()) === -1) {
|
|
buf += newline(file.excerpt) + newline(close);
|
|
}
|
|
}
|
|
return buf + newline(str2);
|
|
};
|
|
function newline(str2) {
|
|
return str2.slice(-1) !== "\n" ? str2 + "\n" : str2;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/excerpt.js
|
|
var require_excerpt = __commonJS({
|
|
"node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/excerpt.js"(exports2, module2) {
|
|
"use strict";
|
|
var defaults = require_defaults();
|
|
module2.exports = function(file, options2) {
|
|
const opts = defaults(options2);
|
|
if (file.data == null) {
|
|
file.data = {};
|
|
}
|
|
if (typeof opts.excerpt === "function") {
|
|
return opts.excerpt(file, opts);
|
|
}
|
|
const sep = file.data.excerpt_separator || opts.excerpt_separator;
|
|
if (sep == null && (opts.excerpt === false || opts.excerpt == null)) {
|
|
return file;
|
|
}
|
|
const delimiter = typeof opts.excerpt === "string" ? opts.excerpt : sep || opts.delimiters[0];
|
|
const idx = file.content.indexOf(delimiter);
|
|
if (idx !== -1) {
|
|
file.excerpt = file.content.slice(0, idx);
|
|
}
|
|
return file;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/to-file.js
|
|
var require_to_file = __commonJS({
|
|
"node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/to-file.js"(exports2, module2) {
|
|
"use strict";
|
|
var typeOf = require_kind_of();
|
|
var stringify = require_stringify();
|
|
var utils = require_utils();
|
|
module2.exports = function(file) {
|
|
if (typeOf(file) !== "object") {
|
|
file = { content: file };
|
|
}
|
|
if (typeOf(file.data) !== "object") {
|
|
file.data = {};
|
|
}
|
|
if (file.contents && file.content == null) {
|
|
file.content = file.contents;
|
|
}
|
|
utils.define(file, "orig", utils.toBuffer(file.content));
|
|
utils.define(file, "language", file.language || "");
|
|
utils.define(file, "matter", file.matter || "");
|
|
utils.define(file, "stringify", function(data, options2) {
|
|
if (options2 && options2.language) {
|
|
file.language = options2.language;
|
|
}
|
|
return stringify(file, data, options2);
|
|
});
|
|
file.content = utils.toString(file.content);
|
|
file.isEmpty = false;
|
|
file.excerpt = "";
|
|
return file;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/parse.js
|
|
var require_parse = __commonJS({
|
|
"node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/lib/parse.js"(exports2, module2) {
|
|
"use strict";
|
|
var getEngine = require_engine();
|
|
var defaults = require_defaults();
|
|
module2.exports = function(language, str2, options2) {
|
|
const opts = defaults(options2);
|
|
const engine = getEngine(language, opts);
|
|
if (typeof engine.parse !== "function") {
|
|
throw new TypeError('expected "' + language + '.parse" to be a function');
|
|
}
|
|
return engine.parse(str2, opts);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js
|
|
var require_gray_matter = __commonJS({
|
|
"node_modules/.pnpm/gray-matter@4.0.3/node_modules/gray-matter/index.js"(exports2, module2) {
|
|
"use strict";
|
|
var fs2 = require("fs");
|
|
var sections = require_section_matter();
|
|
var defaults = require_defaults();
|
|
var stringify = require_stringify();
|
|
var excerpt = require_excerpt();
|
|
var engines2 = require_engines();
|
|
var toFile = require_to_file();
|
|
var parse2 = require_parse();
|
|
var utils = require_utils();
|
|
function matter2(input, options2) {
|
|
if (input === "") {
|
|
return { data: {}, content: input, excerpt: "", orig: input };
|
|
}
|
|
let file = toFile(input);
|
|
const cached = matter2.cache[file.content];
|
|
if (!options2) {
|
|
if (cached) {
|
|
file = Object.assign({}, cached);
|
|
file.orig = cached.orig;
|
|
return file;
|
|
}
|
|
matter2.cache[file.content] = file;
|
|
}
|
|
return parseMatter(file, options2);
|
|
}
|
|
function parseMatter(file, options2) {
|
|
const opts = defaults(options2);
|
|
const open = opts.delimiters[0];
|
|
const close = "\n" + opts.delimiters[1];
|
|
let str2 = file.content;
|
|
if (opts.language) {
|
|
file.language = opts.language;
|
|
}
|
|
const openLen = open.length;
|
|
if (!utils.startsWith(str2, open, openLen)) {
|
|
excerpt(file, opts);
|
|
return file;
|
|
}
|
|
if (str2.charAt(openLen) === open.slice(-1)) {
|
|
return file;
|
|
}
|
|
str2 = str2.slice(openLen);
|
|
const len = str2.length;
|
|
const language = matter2.language(str2, opts);
|
|
if (language.name) {
|
|
file.language = language.name;
|
|
str2 = str2.slice(language.raw.length);
|
|
}
|
|
let closeIndex = str2.indexOf(close);
|
|
if (closeIndex === -1) {
|
|
closeIndex = len;
|
|
}
|
|
file.matter = str2.slice(0, closeIndex);
|
|
const block = file.matter.replace(/^\s*#[^\n]+/gm, "").trim();
|
|
if (block === "") {
|
|
file.isEmpty = true;
|
|
file.empty = file.content;
|
|
file.data = {};
|
|
} else {
|
|
file.data = parse2(file.language, file.matter, opts);
|
|
}
|
|
if (closeIndex === len) {
|
|
file.content = "";
|
|
} else {
|
|
file.content = str2.slice(closeIndex + close.length);
|
|
if (file.content[0] === "\r") {
|
|
file.content = file.content.slice(1);
|
|
}
|
|
if (file.content[0] === "\n") {
|
|
file.content = file.content.slice(1);
|
|
}
|
|
}
|
|
excerpt(file, opts);
|
|
if (opts.sections === true || typeof opts.section === "function") {
|
|
sections(file, opts.section);
|
|
}
|
|
return file;
|
|
}
|
|
matter2.engines = engines2;
|
|
matter2.stringify = function(file, data, options2) {
|
|
if (typeof file === "string") file = matter2(file, options2);
|
|
return stringify(file, data, options2);
|
|
};
|
|
matter2.read = function(filepath, options2) {
|
|
const str2 = fs2.readFileSync(filepath, "utf8");
|
|
const file = matter2(str2, options2);
|
|
file.path = filepath;
|
|
return file;
|
|
};
|
|
matter2.test = function(str2, options2) {
|
|
return utils.startsWith(str2, defaults(options2).delimiters[0]);
|
|
};
|
|
matter2.language = function(str2, options2) {
|
|
const opts = defaults(options2);
|
|
const open = opts.delimiters[0];
|
|
if (matter2.test(str2)) {
|
|
str2 = str2.slice(open.length);
|
|
}
|
|
const language = str2.slice(0, str2.search(/\r?\n/));
|
|
return {
|
|
raw: language,
|
|
name: language ? language.trim() : ""
|
|
};
|
|
};
|
|
matter2.cache = {};
|
|
matter2.clearCache = function() {
|
|
matter2.cache = {};
|
|
};
|
|
module2.exports = matter2;
|
|
}
|
|
});
|
|
|
|
// mcp-server/ws-bridge.js
|
|
var ws_bridge_exports = {};
|
|
__export(ws_bridge_exports, {
|
|
startBridge: () => startBridge,
|
|
startUiBridge: () => startUiBridge
|
|
});
|
|
module.exports = __toCommonJS(ws_bridge_exports);
|
|
var import_node_http = require("node:http");
|
|
|
|
// node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
|
|
var import_stream = __toESM(require_stream(), 1);
|
|
var import_receiver = __toESM(require_receiver(), 1);
|
|
var import_sender = __toESM(require_sender(), 1);
|
|
var import_websocket = __toESM(require_websocket(), 1);
|
|
var import_websocket_server = __toESM(require_websocket_server(), 1);
|
|
|
|
// mcp-server/vault.js
|
|
var import_promises = __toESM(require("node:fs/promises"), 1);
|
|
var import_node_path = __toESM(require("node:path"), 1);
|
|
var import_gray_matter = __toESM(require_gray_matter(), 1);
|
|
async function findMarkdownFiles(dir) {
|
|
const results = [];
|
|
const items = await import_promises.default.readdir(dir, { withFileTypes: true });
|
|
for (const item of items) {
|
|
if (item.name.startsWith(".")) continue;
|
|
const full = import_node_path.default.join(dir, item.name);
|
|
if (item.isDirectory()) {
|
|
results.push(...await findMarkdownFiles(full));
|
|
} else if (item.name.endsWith(".md")) {
|
|
results.push(full);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
async function getNote(vaultPath, notePath) {
|
|
const absPath = import_node_path.default.isAbsolute(notePath) ? notePath : import_node_path.default.join(vaultPath, notePath);
|
|
const raw = await import_promises.default.readFile(absPath, "utf-8");
|
|
const parsed = (0, import_gray_matter.default)(raw);
|
|
return {
|
|
path: import_node_path.default.relative(vaultPath, absPath),
|
|
frontmatter: parsed.data,
|
|
content: parsed.content.trim()
|
|
};
|
|
}
|
|
async function searchNotes(vaultPath, query, limit = 10) {
|
|
const files = await findMarkdownFiles(vaultPath);
|
|
const q = query.toLowerCase();
|
|
const results = [];
|
|
for (const filePath of files) {
|
|
if (results.length >= limit) break;
|
|
const content = await import_promises.default.readFile(filePath, "utf-8");
|
|
const filename = import_node_path.default.basename(filePath, ".md");
|
|
const titleMatch = extractTitle(content, filename);
|
|
const matches = titleMatch.toLowerCase().includes(q) || content.toLowerCase().includes(q);
|
|
if (matches) {
|
|
const snippet = extractSnippet(content, q);
|
|
results.push({
|
|
path: import_node_path.default.relative(vaultPath, filePath),
|
|
title: titleMatch,
|
|
snippet
|
|
});
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
async function vaultContext(vaultPath) {
|
|
const files = await findMarkdownFiles(vaultPath);
|
|
const typesSet = /* @__PURE__ */ new Set();
|
|
const foldersSet = /* @__PURE__ */ new Set();
|
|
const notesWithMtime = [];
|
|
for (const filePath of files) {
|
|
const raw = await import_promises.default.readFile(filePath, "utf-8");
|
|
const parsed = (0, import_gray_matter.default)(raw);
|
|
const type = parsed.data.type || parsed.data.is_a || null;
|
|
if (type) typesSet.add(type);
|
|
const rel = import_node_path.default.relative(vaultPath, filePath);
|
|
const topFolder = rel.split(import_node_path.default.sep)[0];
|
|
if (topFolder !== rel) foldersSet.add(topFolder + "/");
|
|
const stat = await import_promises.default.stat(filePath);
|
|
notesWithMtime.push({
|
|
path: rel,
|
|
title: parsed.data.title || extractTitle(raw, import_node_path.default.basename(filePath, ".md")),
|
|
type,
|
|
mtime: stat.mtimeMs
|
|
});
|
|
}
|
|
notesWithMtime.sort((a, b) => b.mtime - a.mtime);
|
|
const recentNotes = notesWithMtime.slice(0, 20).map(({ mtime: _mtime, ...rest }) => rest);
|
|
const configFiles = {};
|
|
try {
|
|
const agentsPath = import_node_path.default.join(vaultPath, "config", "agents.md");
|
|
const agentsContent = await import_promises.default.readFile(agentsPath, "utf-8");
|
|
configFiles.agents = agentsContent;
|
|
} catch {
|
|
}
|
|
return {
|
|
types: [...typesSet].sort(),
|
|
noteCount: files.length,
|
|
folders: [...foldersSet].sort(),
|
|
recentNotes,
|
|
configFiles,
|
|
vaultPath
|
|
};
|
|
}
|
|
function extractTitle(content, fallback) {
|
|
const h1Match = content.match(/^#\s+(.+)$/m);
|
|
if (h1Match) return h1Match[1].trim();
|
|
const titleMatch = content.match(/^title:\s*(.+)$/m);
|
|
if (titleMatch) return titleMatch[1].trim();
|
|
return fallback;
|
|
}
|
|
function extractSnippet(content, query) {
|
|
const body = content.replace(/^---[\s\S]*?---\n?/, "").trim();
|
|
const idx = body.toLowerCase().indexOf(query);
|
|
if (idx === -1) return body.slice(0, 120);
|
|
const start = Math.max(0, idx - 40);
|
|
const end = Math.min(body.length, idx + query.length + 80);
|
|
return (start > 0 ? "..." : "") + body.slice(start, end) + (end < body.length ? "..." : "");
|
|
}
|
|
|
|
// mcp-server/ws-bridge.js
|
|
var VAULT_PATH = process.env.VAULT_PATH || process.env.HOME + "/Laputa";
|
|
var WS_PORT = parseInt(process.env.WS_PORT || "9710", 10);
|
|
var WS_UI_PORT = parseInt(process.env.WS_UI_PORT || "9711", 10);
|
|
var uiBridge = null;
|
|
function broadcastUiAction(action, payload) {
|
|
if (!uiBridge) return;
|
|
const msg = JSON.stringify({ type: "ui_action", action, ...payload });
|
|
for (const client of uiBridge.clients) {
|
|
if (client.readyState === 1) client.send(msg);
|
|
}
|
|
}
|
|
var TOOL_HANDLERS = {
|
|
open_note: (args) => getNote(VAULT_PATH, args.path).then((note) => ({ content: note.content, frontmatter: note.frontmatter })),
|
|
read_note: (args) => getNote(VAULT_PATH, args.path).then((note) => ({ content: note.content, frontmatter: note.frontmatter })),
|
|
search_notes: (args) => searchNotes(VAULT_PATH, args.query, args.limit),
|
|
vault_context: () => vaultContext(VAULT_PATH),
|
|
ui_open_note: (args) => {
|
|
broadcastUiAction("vault_changed", { path: args.path });
|
|
broadcastUiAction("open_note", { path: args.path });
|
|
return { ok: true };
|
|
},
|
|
ui_open_tab: (args) => {
|
|
broadcastUiAction("vault_changed", { path: args.path });
|
|
broadcastUiAction("open_tab", { path: args.path });
|
|
return { ok: true };
|
|
},
|
|
ui_highlight: (args) => {
|
|
broadcastUiAction("highlight", { element: args.element, path: args.path });
|
|
return { ok: true };
|
|
},
|
|
ui_set_filter: (args) => {
|
|
broadcastUiAction("set_filter", { filterType: args.type });
|
|
return { ok: true };
|
|
},
|
|
highlight_editor: (args) => {
|
|
broadcastUiAction("highlight", { element: args.element, path: args.path });
|
|
return { ok: true };
|
|
},
|
|
refresh_vault: (args) => {
|
|
broadcastUiAction("vault_changed", { path: args?.path });
|
|
return { ok: true };
|
|
}
|
|
};
|
|
async function handleMessage(data) {
|
|
const msg = JSON.parse(data);
|
|
const { id, tool, args } = msg;
|
|
const handler = TOOL_HANDLERS[tool];
|
|
if (!handler) {
|
|
return { id, error: `Unknown tool: ${tool}` };
|
|
}
|
|
try {
|
|
const result = await handler(args || {});
|
|
return { id, result };
|
|
} catch (err) {
|
|
return { id, error: err.message };
|
|
}
|
|
}
|
|
function startUiBridge(port = WS_UI_PORT) {
|
|
return new Promise((resolve) => {
|
|
const httpServer = (0, import_node_http.createServer)();
|
|
httpServer.on("error", (err) => {
|
|
if (err.code === "EADDRINUSE") {
|
|
console.error(`[ws-bridge] UI bridge port ${port} already in use, disabling bridge`);
|
|
} else {
|
|
console.error(`[ws-bridge] UI bridge error: ${err.message}`);
|
|
}
|
|
resolve(null);
|
|
});
|
|
httpServer.listen(port, () => {
|
|
const wss = new import_websocket_server.default({ server: httpServer });
|
|
wss.on("connection", (ws) => {
|
|
console.error(`[ws-bridge] UI client connected on port ${port}`);
|
|
ws.on("message", (raw) => {
|
|
for (const client of wss.clients) {
|
|
if (client !== ws && client.readyState === 1) client.send(raw.toString());
|
|
}
|
|
});
|
|
});
|
|
uiBridge = wss;
|
|
console.error(`[ws-bridge] UI bridge listening on ws://localhost:${port}`);
|
|
resolve(wss);
|
|
});
|
|
});
|
|
}
|
|
function startBridge(port = WS_PORT) {
|
|
const wss = new import_websocket_server.default({ port });
|
|
wss.on("connection", (ws) => {
|
|
console.error(`[ws-bridge] Client connected (vault: ${VAULT_PATH})`);
|
|
ws.on("message", async (raw) => {
|
|
try {
|
|
const response = await handleMessage(raw.toString());
|
|
ws.send(JSON.stringify(response));
|
|
} catch (err) {
|
|
ws.send(JSON.stringify({ error: `Parse error: ${err.message}` }));
|
|
}
|
|
});
|
|
ws.on("close", () => console.error("[ws-bridge] Client disconnected"));
|
|
});
|
|
console.error(`[ws-bridge] Listening on ws://localhost:${port}`);
|
|
return wss;
|
|
}
|
|
var isMain = process.argv[1]?.endsWith("ws-bridge.js");
|
|
if (isMain) {
|
|
startUiBridge().then(() => startBridge());
|
|
}
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
startBridge,
|
|
startUiBridge
|
|
});
|
|
/*! Bundled license information:
|
|
|
|
is-extendable/index.js:
|
|
(*!
|
|
* is-extendable <https://github.com/jonschlinkert/is-extendable>
|
|
*
|
|
* Copyright (c) 2015, Jon Schlinkert.
|
|
* Licensed under the MIT License.
|
|
*)
|
|
|
|
strip-bom-string/index.js:
|
|
(*!
|
|
* strip-bom-string <https://github.com/jonschlinkert/strip-bom-string>
|
|
*
|
|
* Copyright (c) 2015, 2017, Jon Schlinkert.
|
|
* Released under the MIT License.
|
|
*)
|
|
*/
|