fixparser-plugin-messagestore-kdb 9.2.3 → 9.3.0-bb19a1db

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,4302 +1,8 @@
1
- "use strict";
2
- var __create = Object.create;
3
- var __defProp = Object.defineProperty;
4
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
- var __getOwnPropNames = Object.getOwnPropertyNames;
6
- var __getProtoOf = Object.getPrototypeOf;
7
- var __hasOwnProp = Object.prototype.hasOwnProperty;
8
- var __commonJS = (cb, mod) => function __require() {
9
- return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
10
- };
11
- var __export = (target, all) => {
12
- for (var name in all)
13
- __defProp(target, name, { get: all[name], enumerable: true });
14
- };
15
- var __copyProps = (to, from, except, desc) => {
16
- if (from && typeof from === "object" || typeof from === "function") {
17
- for (let key of __getOwnPropNames(from))
18
- if (!__hasOwnProp.call(to, key) && key !== except)
19
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
20
- }
21
- return to;
22
- };
23
- var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
24
- // If the importer is in node compatibility mode or this is not an ESM
25
- // file that has been converted to a CommonJS file using a Babel-
26
- // compatible transform (i.e. "__esModule" has not been set), then set
27
- // "default" to the CommonJS "module.exports" for node compatibility.
28
- isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
29
- mod
30
- ));
31
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
32
-
33
- // ../../node_modules/ws/lib/constants.js
34
- var require_constants = __commonJS({
35
- "../../node_modules/ws/lib/constants.js"(exports2, module2) {
36
- "use strict";
37
- var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
38
- var hasBlob = typeof Blob !== "undefined";
39
- if (hasBlob) BINARY_TYPES.push("blob");
40
- module2.exports = {
41
- BINARY_TYPES,
42
- EMPTY_BUFFER: Buffer.alloc(0),
43
- GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
44
- hasBlob,
45
- kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
46
- kListener: Symbol("kListener"),
47
- kStatusCode: Symbol("status-code"),
48
- kWebSocket: Symbol("websocket"),
49
- NOOP: () => {
50
- }
51
- };
52
- }
53
- });
54
-
55
- // ../../node_modules/ws/lib/buffer-util.js
56
- var require_buffer_util = __commonJS({
57
- "../../node_modules/ws/lib/buffer-util.js"(exports2, module2) {
58
- "use strict";
59
- var { EMPTY_BUFFER } = require_constants();
60
- var FastBuffer = Buffer[Symbol.species];
61
- function concat(list, totalLength) {
62
- if (list.length === 0) return EMPTY_BUFFER;
63
- if (list.length === 1) return list[0];
64
- const target = Buffer.allocUnsafe(totalLength);
65
- let offset = 0;
66
- for (let i = 0; i < list.length; i++) {
67
- const buf = list[i];
68
- target.set(buf, offset);
69
- offset += buf.length;
70
- }
71
- if (offset < totalLength) {
72
- return new FastBuffer(target.buffer, target.byteOffset, offset);
73
- }
74
- return target;
75
- }
76
- function _mask(source, mask, output, offset, length) {
77
- for (let i = 0; i < length; i++) {
78
- output[offset + i] = source[i] ^ mask[i & 3];
79
- }
80
- }
81
- function _unmask(buffer, mask) {
82
- for (let i = 0; i < buffer.length; i++) {
83
- buffer[i] ^= mask[i & 3];
84
- }
85
- }
86
- function toArrayBuffer(buf) {
87
- if (buf.length === buf.buffer.byteLength) {
88
- return buf.buffer;
89
- }
90
- return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
91
- }
92
- function toBuffer(data) {
93
- toBuffer.readOnly = true;
94
- if (Buffer.isBuffer(data)) return data;
95
- let buf;
96
- if (data instanceof ArrayBuffer) {
97
- buf = new FastBuffer(data);
98
- } else if (ArrayBuffer.isView(data)) {
99
- buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
100
- } else {
101
- buf = Buffer.from(data);
102
- toBuffer.readOnly = false;
103
- }
104
- return buf;
105
- }
106
- module2.exports = {
107
- concat,
108
- mask: _mask,
109
- toArrayBuffer,
110
- toBuffer,
111
- unmask: _unmask
112
- };
113
- if (!process.env.WS_NO_BUFFER_UTIL) {
114
- try {
115
- const bufferUtil = require("bufferutil");
116
- module2.exports.mask = function(source, mask, output, offset, length) {
117
- if (length < 48) _mask(source, mask, output, offset, length);
118
- else bufferUtil.mask(source, mask, output, offset, length);
119
- };
120
- module2.exports.unmask = function(buffer, mask) {
121
- if (buffer.length < 32) _unmask(buffer, mask);
122
- else bufferUtil.unmask(buffer, mask);
123
- };
124
- } catch (e) {
125
- }
126
- }
127
- }
128
- });
129
-
130
- // ../../node_modules/ws/lib/limiter.js
131
- var require_limiter = __commonJS({
132
- "../../node_modules/ws/lib/limiter.js"(exports2, module2) {
133
- "use strict";
134
- var kDone = Symbol("kDone");
135
- var kRun = Symbol("kRun");
136
- var Limiter = class {
137
- /**
138
- * Creates a new `Limiter`.
139
- *
140
- * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
141
- * to run concurrently
142
- */
143
- constructor(concurrency) {
144
- this[kDone] = () => {
145
- this.pending--;
146
- this[kRun]();
147
- };
148
- this.concurrency = concurrency || Infinity;
149
- this.jobs = [];
150
- this.pending = 0;
151
- }
152
- /**
153
- * Adds a job to the queue.
154
- *
155
- * @param {Function} job The job to run
156
- * @public
157
- */
158
- add(job) {
159
- this.jobs.push(job);
160
- this[kRun]();
161
- }
162
- /**
163
- * Removes a job from the queue and runs it if possible.
164
- *
165
- * @private
166
- */
167
- [kRun]() {
168
- if (this.pending === this.concurrency) return;
169
- if (this.jobs.length) {
170
- const job = this.jobs.shift();
171
- this.pending++;
172
- job(this[kDone]);
173
- }
174
- }
175
- };
176
- module2.exports = Limiter;
177
- }
178
- });
179
-
180
- // ../../node_modules/ws/lib/permessage-deflate.js
181
- var require_permessage_deflate = __commonJS({
182
- "../../node_modules/ws/lib/permessage-deflate.js"(exports2, module2) {
183
- "use strict";
184
- var zlib = require("zlib");
185
- var bufferUtil = require_buffer_util();
186
- var Limiter = require_limiter();
187
- var { kStatusCode } = require_constants();
188
- var FastBuffer = Buffer[Symbol.species];
189
- var TRAILER = Buffer.from([0, 0, 255, 255]);
190
- var kPerMessageDeflate = Symbol("permessage-deflate");
191
- var kTotalLength = Symbol("total-length");
192
- var kCallback = Symbol("callback");
193
- var kBuffers = Symbol("buffers");
194
- var kError = Symbol("error");
195
- var zlibLimiter;
196
- var PerMessageDeflate = class {
197
- /**
198
- * Creates a PerMessageDeflate instance.
199
- *
200
- * @param {Object} [options] Configuration options
201
- * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
202
- * for, or request, a custom client window size
203
- * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
204
- * acknowledge disabling of client context takeover
205
- * @param {Number} [options.concurrencyLimit=10] The number of concurrent
206
- * calls to zlib
207
- * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
208
- * use of a custom server window size
209
- * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
210
- * disabling of server context takeover
211
- * @param {Number} [options.threshold=1024] Size (in bytes) below which
212
- * messages should not be compressed if context takeover is disabled
213
- * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
214
- * deflate
215
- * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
216
- * inflate
217
- * @param {Boolean} [isServer=false] Create the instance in either server or
218
- * client mode
219
- * @param {Number} [maxPayload=0] The maximum allowed message length
220
- */
221
- constructor(options, isServer, maxPayload) {
222
- this._maxPayload = maxPayload | 0;
223
- this._options = options || {};
224
- this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
225
- this._isServer = !!isServer;
226
- this._deflate = null;
227
- this._inflate = null;
228
- this.params = null;
229
- if (!zlibLimiter) {
230
- const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
231
- zlibLimiter = new Limiter(concurrency);
232
- }
233
- }
234
- /**
235
- * @type {String}
236
- */
237
- static get extensionName() {
238
- return "permessage-deflate";
239
- }
240
- /**
241
- * Create an extension negotiation offer.
242
- *
243
- * @return {Object} Extension parameters
244
- * @public
245
- */
246
- offer() {
247
- const params = {};
248
- if (this._options.serverNoContextTakeover) {
249
- params.server_no_context_takeover = true;
250
- }
251
- if (this._options.clientNoContextTakeover) {
252
- params.client_no_context_takeover = true;
253
- }
254
- if (this._options.serverMaxWindowBits) {
255
- params.server_max_window_bits = this._options.serverMaxWindowBits;
256
- }
257
- if (this._options.clientMaxWindowBits) {
258
- params.client_max_window_bits = this._options.clientMaxWindowBits;
259
- } else if (this._options.clientMaxWindowBits == null) {
260
- params.client_max_window_bits = true;
261
- }
262
- return params;
263
- }
264
- /**
265
- * Accept an extension negotiation offer/response.
266
- *
267
- * @param {Array} configurations The extension negotiation offers/reponse
268
- * @return {Object} Accepted configuration
269
- * @public
270
- */
271
- accept(configurations) {
272
- configurations = this.normalizeParams(configurations);
273
- this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
274
- return this.params;
275
- }
276
- /**
277
- * Releases all resources used by the extension.
278
- *
279
- * @public
280
- */
281
- cleanup() {
282
- if (this._inflate) {
283
- this._inflate.close();
284
- this._inflate = null;
285
- }
286
- if (this._deflate) {
287
- const callback = this._deflate[kCallback];
288
- this._deflate.close();
289
- this._deflate = null;
290
- if (callback) {
291
- callback(
292
- new Error(
293
- "The deflate stream was closed while data was being processed"
294
- )
295
- );
296
- }
297
- }
298
- }
299
- /**
300
- * Accept an extension negotiation offer.
301
- *
302
- * @param {Array} offers The extension negotiation offers
303
- * @return {Object} Accepted configuration
304
- * @private
305
- */
306
- acceptAsServer(offers) {
307
- const opts = this._options;
308
- const accepted = offers.find((params) => {
309
- 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) {
310
- return false;
311
- }
312
- return true;
313
- });
314
- if (!accepted) {
315
- throw new Error("None of the extension offers can be accepted");
316
- }
317
- if (opts.serverNoContextTakeover) {
318
- accepted.server_no_context_takeover = true;
319
- }
320
- if (opts.clientNoContextTakeover) {
321
- accepted.client_no_context_takeover = true;
322
- }
323
- if (typeof opts.serverMaxWindowBits === "number") {
324
- accepted.server_max_window_bits = opts.serverMaxWindowBits;
325
- }
326
- if (typeof opts.clientMaxWindowBits === "number") {
327
- accepted.client_max_window_bits = opts.clientMaxWindowBits;
328
- } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
329
- delete accepted.client_max_window_bits;
330
- }
331
- return accepted;
332
- }
333
- /**
334
- * Accept the extension negotiation response.
335
- *
336
- * @param {Array} response The extension negotiation response
337
- * @return {Object} Accepted configuration
338
- * @private
339
- */
340
- acceptAsClient(response) {
341
- const params = response[0];
342
- if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
343
- throw new Error('Unexpected parameter "client_no_context_takeover"');
344
- }
345
- if (!params.client_max_window_bits) {
346
- if (typeof this._options.clientMaxWindowBits === "number") {
347
- params.client_max_window_bits = this._options.clientMaxWindowBits;
348
- }
349
- } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
350
- throw new Error(
351
- 'Unexpected or invalid parameter "client_max_window_bits"'
352
- );
353
- }
354
- return params;
355
- }
356
- /**
357
- * Normalize parameters.
358
- *
359
- * @param {Array} configurations The extension negotiation offers/reponse
360
- * @return {Array} The offers/response with normalized parameters
361
- * @private
362
- */
363
- normalizeParams(configurations) {
364
- configurations.forEach((params) => {
365
- Object.keys(params).forEach((key) => {
366
- let value = params[key];
367
- if (value.length > 1) {
368
- throw new Error(`Parameter "${key}" must have only a single value`);
369
- }
370
- value = value[0];
371
- if (key === "client_max_window_bits") {
372
- if (value !== true) {
373
- const num = +value;
374
- if (!Number.isInteger(num) || num < 8 || num > 15) {
375
- throw new TypeError(
376
- `Invalid value for parameter "${key}": ${value}`
377
- );
378
- }
379
- value = num;
380
- } else if (!this._isServer) {
381
- throw new TypeError(
382
- `Invalid value for parameter "${key}": ${value}`
383
- );
384
- }
385
- } else if (key === "server_max_window_bits") {
386
- const num = +value;
387
- if (!Number.isInteger(num) || num < 8 || num > 15) {
388
- throw new TypeError(
389
- `Invalid value for parameter "${key}": ${value}`
390
- );
391
- }
392
- value = num;
393
- } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
394
- if (value !== true) {
395
- throw new TypeError(
396
- `Invalid value for parameter "${key}": ${value}`
397
- );
398
- }
399
- } else {
400
- throw new Error(`Unknown parameter "${key}"`);
401
- }
402
- params[key] = value;
403
- });
404
- });
405
- return configurations;
406
- }
407
- /**
408
- * Decompress data. Concurrency limited.
409
- *
410
- * @param {Buffer} data Compressed data
411
- * @param {Boolean} fin Specifies whether or not this is the last fragment
412
- * @param {Function} callback Callback
413
- * @public
414
- */
415
- decompress(data, fin, callback) {
416
- zlibLimiter.add((done) => {
417
- this._decompress(data, fin, (err, result) => {
418
- done();
419
- callback(err, result);
420
- });
421
- });
422
- }
423
- /**
424
- * Compress data. Concurrency limited.
425
- *
426
- * @param {(Buffer|String)} data Data to compress
427
- * @param {Boolean} fin Specifies whether or not this is the last fragment
428
- * @param {Function} callback Callback
429
- * @public
430
- */
431
- compress(data, fin, callback) {
432
- zlibLimiter.add((done) => {
433
- this._compress(data, fin, (err, result) => {
434
- done();
435
- callback(err, result);
436
- });
437
- });
438
- }
439
- /**
440
- * Decompress data.
441
- *
442
- * @param {Buffer} data Compressed data
443
- * @param {Boolean} fin Specifies whether or not this is the last fragment
444
- * @param {Function} callback Callback
445
- * @private
446
- */
447
- _decompress(data, fin, callback) {
448
- const endpoint = this._isServer ? "client" : "server";
449
- if (!this._inflate) {
450
- const key = `${endpoint}_max_window_bits`;
451
- const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
452
- this._inflate = zlib.createInflateRaw({
453
- ...this._options.zlibInflateOptions,
454
- windowBits
455
- });
456
- this._inflate[kPerMessageDeflate] = this;
457
- this._inflate[kTotalLength] = 0;
458
- this._inflate[kBuffers] = [];
459
- this._inflate.on("error", inflateOnError);
460
- this._inflate.on("data", inflateOnData);
461
- }
462
- this._inflate[kCallback] = callback;
463
- this._inflate.write(data);
464
- if (fin) this._inflate.write(TRAILER);
465
- this._inflate.flush(() => {
466
- const err = this._inflate[kError];
467
- if (err) {
468
- this._inflate.close();
469
- this._inflate = null;
470
- callback(err);
471
- return;
472
- }
473
- const data2 = bufferUtil.concat(
474
- this._inflate[kBuffers],
475
- this._inflate[kTotalLength]
476
- );
477
- if (this._inflate._readableState.endEmitted) {
478
- this._inflate.close();
479
- this._inflate = null;
480
- } else {
481
- this._inflate[kTotalLength] = 0;
482
- this._inflate[kBuffers] = [];
483
- if (fin && this.params[`${endpoint}_no_context_takeover`]) {
484
- this._inflate.reset();
485
- }
486
- }
487
- callback(null, data2);
488
- });
489
- }
490
- /**
491
- * Compress data.
492
- *
493
- * @param {(Buffer|String)} data Data to compress
494
- * @param {Boolean} fin Specifies whether or not this is the last fragment
495
- * @param {Function} callback Callback
496
- * @private
497
- */
498
- _compress(data, fin, callback) {
499
- const endpoint = this._isServer ? "server" : "client";
500
- if (!this._deflate) {
501
- const key = `${endpoint}_max_window_bits`;
502
- const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
503
- this._deflate = zlib.createDeflateRaw({
504
- ...this._options.zlibDeflateOptions,
505
- windowBits
506
- });
507
- this._deflate[kTotalLength] = 0;
508
- this._deflate[kBuffers] = [];
509
- this._deflate.on("data", deflateOnData);
510
- }
511
- this._deflate[kCallback] = callback;
512
- this._deflate.write(data);
513
- this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
514
- if (!this._deflate) {
515
- return;
516
- }
517
- let data2 = bufferUtil.concat(
518
- this._deflate[kBuffers],
519
- this._deflate[kTotalLength]
520
- );
521
- if (fin) {
522
- data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4);
523
- }
524
- this._deflate[kCallback] = null;
525
- this._deflate[kTotalLength] = 0;
526
- this._deflate[kBuffers] = [];
527
- if (fin && this.params[`${endpoint}_no_context_takeover`]) {
528
- this._deflate.reset();
529
- }
530
- callback(null, data2);
531
- });
532
- }
533
- };
534
- module2.exports = PerMessageDeflate;
535
- function deflateOnData(chunk) {
536
- this[kBuffers].push(chunk);
537
- this[kTotalLength] += chunk.length;
538
- }
539
- function inflateOnData(chunk) {
540
- this[kTotalLength] += chunk.length;
541
- if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
542
- this[kBuffers].push(chunk);
543
- return;
544
- }
545
- this[kError] = new RangeError("Max payload size exceeded");
546
- this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
547
- this[kError][kStatusCode] = 1009;
548
- this.removeListener("data", inflateOnData);
549
- this.reset();
550
- }
551
- function inflateOnError(err) {
552
- this[kPerMessageDeflate]._inflate = null;
553
- if (this[kError]) {
554
- this[kCallback](this[kError]);
555
- return;
556
- }
557
- err[kStatusCode] = 1007;
558
- this[kCallback](err);
559
- }
560
- }
561
- });
562
-
563
- // ../../node_modules/ws/lib/validation.js
564
- var require_validation = __commonJS({
565
- "../../node_modules/ws/lib/validation.js"(exports2, module2) {
566
- "use strict";
567
- var { isUtf8 } = require("buffer");
568
- var { hasBlob } = require_constants();
569
- var tokenChars = [
570
- 0,
571
- 0,
572
- 0,
573
- 0,
574
- 0,
575
- 0,
576
- 0,
577
- 0,
578
- 0,
579
- 0,
580
- 0,
581
- 0,
582
- 0,
583
- 0,
584
- 0,
585
- 0,
586
- // 0 - 15
587
- 0,
588
- 0,
589
- 0,
590
- 0,
591
- 0,
592
- 0,
593
- 0,
594
- 0,
595
- 0,
596
- 0,
597
- 0,
598
- 0,
599
- 0,
600
- 0,
601
- 0,
602
- 0,
603
- // 16 - 31
604
- 0,
605
- 1,
606
- 0,
607
- 1,
608
- 1,
609
- 1,
610
- 1,
611
- 1,
612
- 0,
613
- 0,
614
- 1,
615
- 1,
616
- 0,
617
- 1,
618
- 1,
619
- 0,
620
- // 32 - 47
621
- 1,
622
- 1,
623
- 1,
624
- 1,
625
- 1,
626
- 1,
627
- 1,
628
- 1,
629
- 1,
630
- 1,
631
- 0,
632
- 0,
633
- 0,
634
- 0,
635
- 0,
636
- 0,
637
- // 48 - 63
638
- 0,
639
- 1,
640
- 1,
641
- 1,
642
- 1,
643
- 1,
644
- 1,
645
- 1,
646
- 1,
647
- 1,
648
- 1,
649
- 1,
650
- 1,
651
- 1,
652
- 1,
653
- 1,
654
- // 64 - 79
655
- 1,
656
- 1,
657
- 1,
658
- 1,
659
- 1,
660
- 1,
661
- 1,
662
- 1,
663
- 1,
664
- 1,
665
- 1,
666
- 0,
667
- 0,
668
- 0,
669
- 1,
670
- 1,
671
- // 80 - 95
672
- 1,
673
- 1,
674
- 1,
675
- 1,
676
- 1,
677
- 1,
678
- 1,
679
- 1,
680
- 1,
681
- 1,
682
- 1,
683
- 1,
684
- 1,
685
- 1,
686
- 1,
687
- 1,
688
- // 96 - 111
689
- 1,
690
- 1,
691
- 1,
692
- 1,
693
- 1,
694
- 1,
695
- 1,
696
- 1,
697
- 1,
698
- 1,
699
- 1,
700
- 0,
701
- 1,
702
- 0,
703
- 1,
704
- 0
705
- // 112 - 127
706
- ];
707
- function isValidStatusCode(code) {
708
- return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
709
- }
710
- function _isValidUTF8(buf) {
711
- const len = buf.length;
712
- let i = 0;
713
- while (i < len) {
714
- if ((buf[i] & 128) === 0) {
715
- i++;
716
- } else if ((buf[i] & 224) === 192) {
717
- if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) {
718
- return false;
719
- }
720
- i += 2;
721
- } else if ((buf[i] & 240) === 224) {
722
- if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || // Overlong
723
- buf[i] === 237 && (buf[i + 1] & 224) === 160) {
724
- return false;
725
- }
726
- i += 3;
727
- } else if ((buf[i] & 248) === 240) {
728
- 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
729
- buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) {
730
- return false;
731
- }
732
- i += 4;
733
- } else {
734
- return false;
735
- }
736
- }
737
- return true;
738
- }
739
- function isBlob(value) {
740
- 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");
741
- }
742
- module2.exports = {
743
- isBlob,
744
- isValidStatusCode,
745
- isValidUTF8: _isValidUTF8,
746
- tokenChars
747
- };
748
- if (isUtf8) {
749
- module2.exports.isValidUTF8 = function(buf) {
750
- return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
751
- };
752
- } else if (!process.env.WS_NO_UTF_8_VALIDATE) {
753
- try {
754
- const isValidUTF8 = require("utf-8-validate");
755
- module2.exports.isValidUTF8 = function(buf) {
756
- return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
757
- };
758
- } catch (e) {
759
- }
760
- }
761
- }
762
- });
763
-
764
- // ../../node_modules/ws/lib/receiver.js
765
- var require_receiver = __commonJS({
766
- "../../node_modules/ws/lib/receiver.js"(exports2, module2) {
767
- "use strict";
768
- var { Writable } = require("stream");
769
- var PerMessageDeflate = require_permessage_deflate();
770
- var {
771
- BINARY_TYPES,
772
- EMPTY_BUFFER,
773
- kStatusCode,
774
- kWebSocket
775
- } = require_constants();
776
- var { concat, toArrayBuffer, unmask } = require_buffer_util();
777
- var { isValidStatusCode, isValidUTF8 } = require_validation();
778
- var FastBuffer = Buffer[Symbol.species];
779
- var GET_INFO = 0;
780
- var GET_PAYLOAD_LENGTH_16 = 1;
781
- var GET_PAYLOAD_LENGTH_64 = 2;
782
- var GET_MASK = 3;
783
- var GET_DATA = 4;
784
- var INFLATING = 5;
785
- var DEFER_EVENT = 6;
786
- var Receiver2 = class extends Writable {
787
- /**
788
- * Creates a Receiver instance.
789
- *
790
- * @param {Object} [options] Options object
791
- * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
792
- * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
793
- * multiple times in the same tick
794
- * @param {String} [options.binaryType=nodebuffer] The type for binary data
795
- * @param {Object} [options.extensions] An object containing the negotiated
796
- * extensions
797
- * @param {Boolean} [options.isServer=false] Specifies whether to operate in
798
- * client or server mode
799
- * @param {Number} [options.maxPayload=0] The maximum allowed message length
800
- * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
801
- * not to skip UTF-8 validation for text and close messages
802
- */
803
- constructor(options = {}) {
804
- super();
805
- this._allowSynchronousEvents = options.allowSynchronousEvents !== void 0 ? options.allowSynchronousEvents : true;
806
- this._binaryType = options.binaryType || BINARY_TYPES[0];
807
- this._extensions = options.extensions || {};
808
- this._isServer = !!options.isServer;
809
- this._maxPayload = options.maxPayload | 0;
810
- this._skipUTF8Validation = !!options.skipUTF8Validation;
811
- this[kWebSocket] = void 0;
812
- this._bufferedBytes = 0;
813
- this._buffers = [];
814
- this._compressed = false;
815
- this._payloadLength = 0;
816
- this._mask = void 0;
817
- this._fragmented = 0;
818
- this._masked = false;
819
- this._fin = false;
820
- this._opcode = 0;
821
- this._totalPayloadLength = 0;
822
- this._messageLength = 0;
823
- this._fragments = [];
824
- this._errored = false;
825
- this._loop = false;
826
- this._state = GET_INFO;
827
- }
828
- /**
829
- * Implements `Writable.prototype._write()`.
830
- *
831
- * @param {Buffer} chunk The chunk of data to write
832
- * @param {String} encoding The character encoding of `chunk`
833
- * @param {Function} cb Callback
834
- * @private
835
- */
836
- _write(chunk, encoding, cb) {
837
- if (this._opcode === 8 && this._state == GET_INFO) return cb();
838
- this._bufferedBytes += chunk.length;
839
- this._buffers.push(chunk);
840
- this.startLoop(cb);
841
- }
842
- /**
843
- * Consumes `n` bytes from the buffered data.
844
- *
845
- * @param {Number} n The number of bytes to consume
846
- * @return {Buffer} The consumed bytes
847
- * @private
848
- */
849
- consume(n) {
850
- this._bufferedBytes -= n;
851
- if (n === this._buffers[0].length) return this._buffers.shift();
852
- if (n < this._buffers[0].length) {
853
- const buf = this._buffers[0];
854
- this._buffers[0] = new FastBuffer(
855
- buf.buffer,
856
- buf.byteOffset + n,
857
- buf.length - n
858
- );
859
- return new FastBuffer(buf.buffer, buf.byteOffset, n);
860
- }
861
- const dst = Buffer.allocUnsafe(n);
862
- do {
863
- const buf = this._buffers[0];
864
- const offset = dst.length - n;
865
- if (n >= buf.length) {
866
- dst.set(this._buffers.shift(), offset);
867
- } else {
868
- dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
869
- this._buffers[0] = new FastBuffer(
870
- buf.buffer,
871
- buf.byteOffset + n,
872
- buf.length - n
873
- );
874
- }
875
- n -= buf.length;
876
- } while (n > 0);
877
- return dst;
878
- }
879
- /**
880
- * Starts the parsing loop.
881
- *
882
- * @param {Function} cb Callback
883
- * @private
884
- */
885
- startLoop(cb) {
886
- this._loop = true;
887
- do {
888
- switch (this._state) {
889
- case GET_INFO:
890
- this.getInfo(cb);
891
- break;
892
- case GET_PAYLOAD_LENGTH_16:
893
- this.getPayloadLength16(cb);
894
- break;
895
- case GET_PAYLOAD_LENGTH_64:
896
- this.getPayloadLength64(cb);
897
- break;
898
- case GET_MASK:
899
- this.getMask();
900
- break;
901
- case GET_DATA:
902
- this.getData(cb);
903
- break;
904
- case INFLATING:
905
- case DEFER_EVENT:
906
- this._loop = false;
907
- return;
908
- }
909
- } while (this._loop);
910
- if (!this._errored) cb();
911
- }
912
- /**
913
- * Reads the first two bytes of a frame.
914
- *
915
- * @param {Function} cb Callback
916
- * @private
917
- */
918
- getInfo(cb) {
919
- if (this._bufferedBytes < 2) {
920
- this._loop = false;
921
- return;
922
- }
923
- const buf = this.consume(2);
924
- if ((buf[0] & 48) !== 0) {
925
- const error = this.createError(
926
- RangeError,
927
- "RSV2 and RSV3 must be clear",
928
- true,
929
- 1002,
930
- "WS_ERR_UNEXPECTED_RSV_2_3"
931
- );
932
- cb(error);
933
- return;
934
- }
935
- const compressed2 = (buf[0] & 64) === 64;
936
- if (compressed2 && !this._extensions[PerMessageDeflate.extensionName]) {
937
- const error = this.createError(
938
- RangeError,
939
- "RSV1 must be clear",
940
- true,
941
- 1002,
942
- "WS_ERR_UNEXPECTED_RSV_1"
943
- );
944
- cb(error);
945
- return;
946
- }
947
- this._fin = (buf[0] & 128) === 128;
948
- this._opcode = buf[0] & 15;
949
- this._payloadLength = buf[1] & 127;
950
- if (this._opcode === 0) {
951
- if (compressed2) {
952
- const error = this.createError(
953
- RangeError,
954
- "RSV1 must be clear",
955
- true,
956
- 1002,
957
- "WS_ERR_UNEXPECTED_RSV_1"
958
- );
959
- cb(error);
960
- return;
961
- }
962
- if (!this._fragmented) {
963
- const error = this.createError(
964
- RangeError,
965
- "invalid opcode 0",
966
- true,
967
- 1002,
968
- "WS_ERR_INVALID_OPCODE"
969
- );
970
- cb(error);
971
- return;
972
- }
973
- this._opcode = this._fragmented;
974
- } else if (this._opcode === 1 || this._opcode === 2) {
975
- if (this._fragmented) {
976
- const error = this.createError(
977
- RangeError,
978
- `invalid opcode ${this._opcode}`,
979
- true,
980
- 1002,
981
- "WS_ERR_INVALID_OPCODE"
982
- );
983
- cb(error);
984
- return;
985
- }
986
- this._compressed = compressed2;
987
- } else if (this._opcode > 7 && this._opcode < 11) {
988
- if (!this._fin) {
989
- const error = this.createError(
990
- RangeError,
991
- "FIN must be set",
992
- true,
993
- 1002,
994
- "WS_ERR_EXPECTED_FIN"
995
- );
996
- cb(error);
997
- return;
998
- }
999
- if (compressed2) {
1000
- const error = this.createError(
1001
- RangeError,
1002
- "RSV1 must be clear",
1003
- true,
1004
- 1002,
1005
- "WS_ERR_UNEXPECTED_RSV_1"
1006
- );
1007
- cb(error);
1008
- return;
1009
- }
1010
- if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
1011
- const error = this.createError(
1012
- RangeError,
1013
- `invalid payload length ${this._payloadLength}`,
1014
- true,
1015
- 1002,
1016
- "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
1017
- );
1018
- cb(error);
1019
- return;
1020
- }
1021
- } else {
1022
- const error = this.createError(
1023
- RangeError,
1024
- `invalid opcode ${this._opcode}`,
1025
- true,
1026
- 1002,
1027
- "WS_ERR_INVALID_OPCODE"
1028
- );
1029
- cb(error);
1030
- return;
1031
- }
1032
- if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
1033
- this._masked = (buf[1] & 128) === 128;
1034
- if (this._isServer) {
1035
- if (!this._masked) {
1036
- const error = this.createError(
1037
- RangeError,
1038
- "MASK must be set",
1039
- true,
1040
- 1002,
1041
- "WS_ERR_EXPECTED_MASK"
1042
- );
1043
- cb(error);
1044
- return;
1045
- }
1046
- } else if (this._masked) {
1047
- const error = this.createError(
1048
- RangeError,
1049
- "MASK must be clear",
1050
- true,
1051
- 1002,
1052
- "WS_ERR_UNEXPECTED_MASK"
1053
- );
1054
- cb(error);
1055
- return;
1056
- }
1057
- if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
1058
- else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
1059
- else this.haveLength(cb);
1060
- }
1061
- /**
1062
- * Gets extended payload length (7+16).
1063
- *
1064
- * @param {Function} cb Callback
1065
- * @private
1066
- */
1067
- getPayloadLength16(cb) {
1068
- if (this._bufferedBytes < 2) {
1069
- this._loop = false;
1070
- return;
1071
- }
1072
- this._payloadLength = this.consume(2).readUInt16BE(0);
1073
- this.haveLength(cb);
1074
- }
1075
- /**
1076
- * Gets extended payload length (7+64).
1077
- *
1078
- * @param {Function} cb Callback
1079
- * @private
1080
- */
1081
- getPayloadLength64(cb) {
1082
- if (this._bufferedBytes < 8) {
1083
- this._loop = false;
1084
- return;
1085
- }
1086
- const buf = this.consume(8);
1087
- const num = buf.readUInt32BE(0);
1088
- if (num > Math.pow(2, 53 - 32) - 1) {
1089
- const error = this.createError(
1090
- RangeError,
1091
- "Unsupported WebSocket frame: payload length > 2^53 - 1",
1092
- false,
1093
- 1009,
1094
- "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
1095
- );
1096
- cb(error);
1097
- return;
1098
- }
1099
- this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
1100
- this.haveLength(cb);
1101
- }
1102
- /**
1103
- * Payload length has been read.
1104
- *
1105
- * @param {Function} cb Callback
1106
- * @private
1107
- */
1108
- haveLength(cb) {
1109
- if (this._payloadLength && this._opcode < 8) {
1110
- this._totalPayloadLength += this._payloadLength;
1111
- if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
1112
- const error = this.createError(
1113
- RangeError,
1114
- "Max payload size exceeded",
1115
- false,
1116
- 1009,
1117
- "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
1118
- );
1119
- cb(error);
1120
- return;
1121
- }
1122
- }
1123
- if (this._masked) this._state = GET_MASK;
1124
- else this._state = GET_DATA;
1125
- }
1126
- /**
1127
- * Reads mask bytes.
1128
- *
1129
- * @private
1130
- */
1131
- getMask() {
1132
- if (this._bufferedBytes < 4) {
1133
- this._loop = false;
1134
- return;
1135
- }
1136
- this._mask = this.consume(4);
1137
- this._state = GET_DATA;
1138
- }
1139
- /**
1140
- * Reads data bytes.
1141
- *
1142
- * @param {Function} cb Callback
1143
- * @private
1144
- */
1145
- getData(cb) {
1146
- let data = EMPTY_BUFFER;
1147
- if (this._payloadLength) {
1148
- if (this._bufferedBytes < this._payloadLength) {
1149
- this._loop = false;
1150
- return;
1151
- }
1152
- data = this.consume(this._payloadLength);
1153
- if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) {
1154
- unmask(data, this._mask);
1155
- }
1156
- }
1157
- if (this._opcode > 7) {
1158
- this.controlMessage(data, cb);
1159
- return;
1160
- }
1161
- if (this._compressed) {
1162
- this._state = INFLATING;
1163
- this.decompress(data, cb);
1164
- return;
1165
- }
1166
- if (data.length) {
1167
- this._messageLength = this._totalPayloadLength;
1168
- this._fragments.push(data);
1169
- }
1170
- this.dataMessage(cb);
1171
- }
1172
- /**
1173
- * Decompresses data.
1174
- *
1175
- * @param {Buffer} data Compressed data
1176
- * @param {Function} cb Callback
1177
- * @private
1178
- */
1179
- decompress(data, cb) {
1180
- const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
1181
- perMessageDeflate.decompress(data, this._fin, (err, buf) => {
1182
- if (err) return cb(err);
1183
- if (buf.length) {
1184
- this._messageLength += buf.length;
1185
- if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
1186
- const error = this.createError(
1187
- RangeError,
1188
- "Max payload size exceeded",
1189
- false,
1190
- 1009,
1191
- "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
1192
- );
1193
- cb(error);
1194
- return;
1195
- }
1196
- this._fragments.push(buf);
1197
- }
1198
- this.dataMessage(cb);
1199
- if (this._state === GET_INFO) this.startLoop(cb);
1200
- });
1201
- }
1202
- /**
1203
- * Handles a data message.
1204
- *
1205
- * @param {Function} cb Callback
1206
- * @private
1207
- */
1208
- dataMessage(cb) {
1209
- if (!this._fin) {
1210
- this._state = GET_INFO;
1211
- return;
1212
- }
1213
- const messageLength = this._messageLength;
1214
- const fragments = this._fragments;
1215
- this._totalPayloadLength = 0;
1216
- this._messageLength = 0;
1217
- this._fragmented = 0;
1218
- this._fragments = [];
1219
- if (this._opcode === 2) {
1220
- let data;
1221
- if (this._binaryType === "nodebuffer") {
1222
- data = concat(fragments, messageLength);
1223
- } else if (this._binaryType === "arraybuffer") {
1224
- data = toArrayBuffer(concat(fragments, messageLength));
1225
- } else if (this._binaryType === "blob") {
1226
- data = new Blob(fragments);
1227
- } else {
1228
- data = fragments;
1229
- }
1230
- if (this._allowSynchronousEvents) {
1231
- this.emit("message", data, true);
1232
- this._state = GET_INFO;
1233
- } else {
1234
- this._state = DEFER_EVENT;
1235
- setImmediate(() => {
1236
- this.emit("message", data, true);
1237
- this._state = GET_INFO;
1238
- this.startLoop(cb);
1239
- });
1240
- }
1241
- } else {
1242
- const buf = concat(fragments, messageLength);
1243
- if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
1244
- const error = this.createError(
1245
- Error,
1246
- "invalid UTF-8 sequence",
1247
- true,
1248
- 1007,
1249
- "WS_ERR_INVALID_UTF8"
1250
- );
1251
- cb(error);
1252
- return;
1253
- }
1254
- if (this._state === INFLATING || this._allowSynchronousEvents) {
1255
- this.emit("message", buf, false);
1256
- this._state = GET_INFO;
1257
- } else {
1258
- this._state = DEFER_EVENT;
1259
- setImmediate(() => {
1260
- this.emit("message", buf, false);
1261
- this._state = GET_INFO;
1262
- this.startLoop(cb);
1263
- });
1264
- }
1265
- }
1266
- }
1267
- /**
1268
- * Handles a control message.
1269
- *
1270
- * @param {Buffer} data Data to handle
1271
- * @return {(Error|RangeError|undefined)} A possible error
1272
- * @private
1273
- */
1274
- controlMessage(data, cb) {
1275
- if (this._opcode === 8) {
1276
- if (data.length === 0) {
1277
- this._loop = false;
1278
- this.emit("conclude", 1005, EMPTY_BUFFER);
1279
- this.end();
1280
- } else {
1281
- const code = data.readUInt16BE(0);
1282
- if (!isValidStatusCode(code)) {
1283
- const error = this.createError(
1284
- RangeError,
1285
- `invalid status code ${code}`,
1286
- true,
1287
- 1002,
1288
- "WS_ERR_INVALID_CLOSE_CODE"
1289
- );
1290
- cb(error);
1291
- return;
1292
- }
1293
- const buf = new FastBuffer(
1294
- data.buffer,
1295
- data.byteOffset + 2,
1296
- data.length - 2
1297
- );
1298
- if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
1299
- const error = this.createError(
1300
- Error,
1301
- "invalid UTF-8 sequence",
1302
- true,
1303
- 1007,
1304
- "WS_ERR_INVALID_UTF8"
1305
- );
1306
- cb(error);
1307
- return;
1308
- }
1309
- this._loop = false;
1310
- this.emit("conclude", code, buf);
1311
- this.end();
1312
- }
1313
- this._state = GET_INFO;
1314
- return;
1315
- }
1316
- if (this._allowSynchronousEvents) {
1317
- this.emit(this._opcode === 9 ? "ping" : "pong", data);
1318
- this._state = GET_INFO;
1319
- } else {
1320
- this._state = DEFER_EVENT;
1321
- setImmediate(() => {
1322
- this.emit(this._opcode === 9 ? "ping" : "pong", data);
1323
- this._state = GET_INFO;
1324
- this.startLoop(cb);
1325
- });
1326
- }
1327
- }
1328
- /**
1329
- * Builds an error object.
1330
- *
1331
- * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
1332
- * @param {String} message The error message
1333
- * @param {Boolean} prefix Specifies whether or not to add a default prefix to
1334
- * `message`
1335
- * @param {Number} statusCode The status code
1336
- * @param {String} errorCode The exposed error code
1337
- * @return {(Error|RangeError)} The error
1338
- * @private
1339
- */
1340
- createError(ErrorCtor, message, prefix, statusCode, errorCode) {
1341
- this._loop = false;
1342
- this._errored = true;
1343
- const err = new ErrorCtor(
1344
- prefix ? `Invalid WebSocket frame: ${message}` : message
1345
- );
1346
- Error.captureStackTrace(err, this.createError);
1347
- err.code = errorCode;
1348
- err[kStatusCode] = statusCode;
1349
- return err;
1350
- }
1351
- };
1352
- module2.exports = Receiver2;
1353
- }
1354
- });
1355
-
1356
- // ../../node_modules/ws/lib/sender.js
1357
- var require_sender = __commonJS({
1358
- "../../node_modules/ws/lib/sender.js"(exports2, module2) {
1359
- "use strict";
1360
- var { Duplex } = require("stream");
1361
- var { randomFillSync } = require("crypto");
1362
- var PerMessageDeflate = require_permessage_deflate();
1363
- var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
1364
- var { isBlob, isValidStatusCode } = require_validation();
1365
- var { mask: applyMask, toBuffer } = require_buffer_util();
1366
- var kByteLength = Symbol("kByteLength");
1367
- var maskBuffer = Buffer.alloc(4);
1368
- var RANDOM_POOL_SIZE = 8 * 1024;
1369
- var randomPool;
1370
- var randomPoolPointer = RANDOM_POOL_SIZE;
1371
- var DEFAULT = 0;
1372
- var DEFLATING = 1;
1373
- var GET_BLOB_DATA = 2;
1374
- var Sender2 = class _Sender {
1375
- /**
1376
- * Creates a Sender instance.
1377
- *
1378
- * @param {Duplex} socket The connection socket
1379
- * @param {Object} [extensions] An object containing the negotiated extensions
1380
- * @param {Function} [generateMask] The function used to generate the masking
1381
- * key
1382
- */
1383
- constructor(socket, extensions, generateMask) {
1384
- this._extensions = extensions || {};
1385
- if (generateMask) {
1386
- this._generateMask = generateMask;
1387
- this._maskBuffer = Buffer.alloc(4);
1388
- }
1389
- this._socket = socket;
1390
- this._firstFragment = true;
1391
- this._compress = false;
1392
- this._bufferedBytes = 0;
1393
- this._queue = [];
1394
- this._state = DEFAULT;
1395
- this.onerror = NOOP;
1396
- this[kWebSocket] = void 0;
1397
- }
1398
- /**
1399
- * Frames a piece of data according to the HyBi WebSocket protocol.
1400
- *
1401
- * @param {(Buffer|String)} data The data to frame
1402
- * @param {Object} options Options object
1403
- * @param {Boolean} [options.fin=false] Specifies whether or not to set the
1404
- * FIN bit
1405
- * @param {Function} [options.generateMask] The function used to generate the
1406
- * masking key
1407
- * @param {Boolean} [options.mask=false] Specifies whether or not to mask
1408
- * `data`
1409
- * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
1410
- * key
1411
- * @param {Number} options.opcode The opcode
1412
- * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
1413
- * modified
1414
- * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
1415
- * RSV1 bit
1416
- * @return {(Buffer|String)[]} The framed data
1417
- * @public
1418
- */
1419
- static frame(data, options) {
1420
- let mask;
1421
- let merge = false;
1422
- let offset = 2;
1423
- let skipMasking = false;
1424
- if (options.mask) {
1425
- mask = options.maskBuffer || maskBuffer;
1426
- if (options.generateMask) {
1427
- options.generateMask(mask);
1428
- } else {
1429
- if (randomPoolPointer === RANDOM_POOL_SIZE) {
1430
- if (randomPool === void 0) {
1431
- randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
1432
- }
1433
- randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
1434
- randomPoolPointer = 0;
1435
- }
1436
- mask[0] = randomPool[randomPoolPointer++];
1437
- mask[1] = randomPool[randomPoolPointer++];
1438
- mask[2] = randomPool[randomPoolPointer++];
1439
- mask[3] = randomPool[randomPoolPointer++];
1440
- }
1441
- skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
1442
- offset = 6;
1443
- }
1444
- let dataLength;
1445
- if (typeof data === "string") {
1446
- if ((!options.mask || skipMasking) && options[kByteLength] !== void 0) {
1447
- dataLength = options[kByteLength];
1448
- } else {
1449
- data = Buffer.from(data);
1450
- dataLength = data.length;
1451
- }
1452
- } else {
1453
- dataLength = data.length;
1454
- merge = options.mask && options.readOnly && !skipMasking;
1455
- }
1456
- let payloadLength = dataLength;
1457
- if (dataLength >= 65536) {
1458
- offset += 8;
1459
- payloadLength = 127;
1460
- } else if (dataLength > 125) {
1461
- offset += 2;
1462
- payloadLength = 126;
1463
- }
1464
- const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
1465
- target[0] = options.fin ? options.opcode | 128 : options.opcode;
1466
- if (options.rsv1) target[0] |= 64;
1467
- target[1] = payloadLength;
1468
- if (payloadLength === 126) {
1469
- target.writeUInt16BE(dataLength, 2);
1470
- } else if (payloadLength === 127) {
1471
- target[2] = target[3] = 0;
1472
- target.writeUIntBE(dataLength, 4, 6);
1473
- }
1474
- if (!options.mask) return [target, data];
1475
- target[1] |= 128;
1476
- target[offset - 4] = mask[0];
1477
- target[offset - 3] = mask[1];
1478
- target[offset - 2] = mask[2];
1479
- target[offset - 1] = mask[3];
1480
- if (skipMasking) return [target, data];
1481
- if (merge) {
1482
- applyMask(data, mask, target, offset, dataLength);
1483
- return [target];
1484
- }
1485
- applyMask(data, mask, data, 0, dataLength);
1486
- return [target, data];
1487
- }
1488
- /**
1489
- * Sends a close message to the other peer.
1490
- *
1491
- * @param {Number} [code] The status code component of the body
1492
- * @param {(String|Buffer)} [data] The message component of the body
1493
- * @param {Boolean} [mask=false] Specifies whether or not to mask the message
1494
- * @param {Function} [cb] Callback
1495
- * @public
1496
- */
1497
- close(code, data, mask, cb) {
1498
- let buf;
1499
- if (code === void 0) {
1500
- buf = EMPTY_BUFFER;
1501
- } else if (typeof code !== "number" || !isValidStatusCode(code)) {
1502
- throw new TypeError("First argument must be a valid error code number");
1503
- } else if (data === void 0 || !data.length) {
1504
- buf = Buffer.allocUnsafe(2);
1505
- buf.writeUInt16BE(code, 0);
1506
- } else {
1507
- const length = Buffer.byteLength(data);
1508
- if (length > 123) {
1509
- throw new RangeError("The message must not be greater than 123 bytes");
1510
- }
1511
- buf = Buffer.allocUnsafe(2 + length);
1512
- buf.writeUInt16BE(code, 0);
1513
- if (typeof data === "string") {
1514
- buf.write(data, 2);
1515
- } else {
1516
- buf.set(data, 2);
1517
- }
1518
- }
1519
- const options = {
1520
- [kByteLength]: buf.length,
1521
- fin: true,
1522
- generateMask: this._generateMask,
1523
- mask,
1524
- maskBuffer: this._maskBuffer,
1525
- opcode: 8,
1526
- readOnly: false,
1527
- rsv1: false
1528
- };
1529
- if (this._state !== DEFAULT) {
1530
- this.enqueue([this.dispatch, buf, false, options, cb]);
1531
- } else {
1532
- this.sendFrame(_Sender.frame(buf, options), cb);
1533
- }
1534
- }
1535
- /**
1536
- * Sends a ping message to the other peer.
1537
- *
1538
- * @param {*} data The message to send
1539
- * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
1540
- * @param {Function} [cb] Callback
1541
- * @public
1542
- */
1543
- ping(data, mask, cb) {
1544
- let byteLength;
1545
- let readOnly;
1546
- if (typeof data === "string") {
1547
- byteLength = Buffer.byteLength(data);
1548
- readOnly = false;
1549
- } else if (isBlob(data)) {
1550
- byteLength = data.size;
1551
- readOnly = false;
1552
- } else {
1553
- data = toBuffer(data);
1554
- byteLength = data.length;
1555
- readOnly = toBuffer.readOnly;
1556
- }
1557
- if (byteLength > 125) {
1558
- throw new RangeError("The data size must not be greater than 125 bytes");
1559
- }
1560
- const options = {
1561
- [kByteLength]: byteLength,
1562
- fin: true,
1563
- generateMask: this._generateMask,
1564
- mask,
1565
- maskBuffer: this._maskBuffer,
1566
- opcode: 9,
1567
- readOnly,
1568
- rsv1: false
1569
- };
1570
- if (isBlob(data)) {
1571
- if (this._state !== DEFAULT) {
1572
- this.enqueue([this.getBlobData, data, false, options, cb]);
1573
- } else {
1574
- this.getBlobData(data, false, options, cb);
1575
- }
1576
- } else if (this._state !== DEFAULT) {
1577
- this.enqueue([this.dispatch, data, false, options, cb]);
1578
- } else {
1579
- this.sendFrame(_Sender.frame(data, options), cb);
1580
- }
1581
- }
1582
- /**
1583
- * Sends a pong message to the other peer.
1584
- *
1585
- * @param {*} data The message to send
1586
- * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
1587
- * @param {Function} [cb] Callback
1588
- * @public
1589
- */
1590
- pong(data, mask, cb) {
1591
- let byteLength;
1592
- let readOnly;
1593
- if (typeof data === "string") {
1594
- byteLength = Buffer.byteLength(data);
1595
- readOnly = false;
1596
- } else if (isBlob(data)) {
1597
- byteLength = data.size;
1598
- readOnly = false;
1599
- } else {
1600
- data = toBuffer(data);
1601
- byteLength = data.length;
1602
- readOnly = toBuffer.readOnly;
1603
- }
1604
- if (byteLength > 125) {
1605
- throw new RangeError("The data size must not be greater than 125 bytes");
1606
- }
1607
- const options = {
1608
- [kByteLength]: byteLength,
1609
- fin: true,
1610
- generateMask: this._generateMask,
1611
- mask,
1612
- maskBuffer: this._maskBuffer,
1613
- opcode: 10,
1614
- readOnly,
1615
- rsv1: false
1616
- };
1617
- if (isBlob(data)) {
1618
- if (this._state !== DEFAULT) {
1619
- this.enqueue([this.getBlobData, data, false, options, cb]);
1620
- } else {
1621
- this.getBlobData(data, false, options, cb);
1622
- }
1623
- } else if (this._state !== DEFAULT) {
1624
- this.enqueue([this.dispatch, data, false, options, cb]);
1625
- } else {
1626
- this.sendFrame(_Sender.frame(data, options), cb);
1627
- }
1628
- }
1629
- /**
1630
- * Sends a data message to the other peer.
1631
- *
1632
- * @param {*} data The message to send
1633
- * @param {Object} options Options object
1634
- * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
1635
- * or text
1636
- * @param {Boolean} [options.compress=false] Specifies whether or not to
1637
- * compress `data`
1638
- * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
1639
- * last one
1640
- * @param {Boolean} [options.mask=false] Specifies whether or not to mask
1641
- * `data`
1642
- * @param {Function} [cb] Callback
1643
- * @public
1644
- */
1645
- send(data, options, cb) {
1646
- const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
1647
- let opcode = options.binary ? 2 : 1;
1648
- let rsv1 = options.compress;
1649
- let byteLength;
1650
- let readOnly;
1651
- if (typeof data === "string") {
1652
- byteLength = Buffer.byteLength(data);
1653
- readOnly = false;
1654
- } else if (isBlob(data)) {
1655
- byteLength = data.size;
1656
- readOnly = false;
1657
- } else {
1658
- data = toBuffer(data);
1659
- byteLength = data.length;
1660
- readOnly = toBuffer.readOnly;
1661
- }
1662
- if (this._firstFragment) {
1663
- this._firstFragment = false;
1664
- if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) {
1665
- rsv1 = byteLength >= perMessageDeflate._threshold;
1666
- }
1667
- this._compress = rsv1;
1668
- } else {
1669
- rsv1 = false;
1670
- opcode = 0;
1671
- }
1672
- if (options.fin) this._firstFragment = true;
1673
- const opts = {
1674
- [kByteLength]: byteLength,
1675
- fin: options.fin,
1676
- generateMask: this._generateMask,
1677
- mask: options.mask,
1678
- maskBuffer: this._maskBuffer,
1679
- opcode,
1680
- readOnly,
1681
- rsv1
1682
- };
1683
- if (isBlob(data)) {
1684
- if (this._state !== DEFAULT) {
1685
- this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
1686
- } else {
1687
- this.getBlobData(data, this._compress, opts, cb);
1688
- }
1689
- } else if (this._state !== DEFAULT) {
1690
- this.enqueue([this.dispatch, data, this._compress, opts, cb]);
1691
- } else {
1692
- this.dispatch(data, this._compress, opts, cb);
1693
- }
1694
- }
1695
- /**
1696
- * Gets the contents of a blob as binary data.
1697
- *
1698
- * @param {Blob} blob The blob
1699
- * @param {Boolean} [compress=false] Specifies whether or not to compress
1700
- * the data
1701
- * @param {Object} options Options object
1702
- * @param {Boolean} [options.fin=false] Specifies whether or not to set the
1703
- * FIN bit
1704
- * @param {Function} [options.generateMask] The function used to generate the
1705
- * masking key
1706
- * @param {Boolean} [options.mask=false] Specifies whether or not to mask
1707
- * `data`
1708
- * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
1709
- * key
1710
- * @param {Number} options.opcode The opcode
1711
- * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
1712
- * modified
1713
- * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
1714
- * RSV1 bit
1715
- * @param {Function} [cb] Callback
1716
- * @private
1717
- */
1718
- getBlobData(blob, compress, options, cb) {
1719
- this._bufferedBytes += options[kByteLength];
1720
- this._state = GET_BLOB_DATA;
1721
- blob.arrayBuffer().then((arrayBuffer) => {
1722
- if (this._socket.destroyed) {
1723
- const err = new Error(
1724
- "The socket was closed while the blob was being read"
1725
- );
1726
- process.nextTick(callCallbacks, this, err, cb);
1727
- return;
1728
- }
1729
- this._bufferedBytes -= options[kByteLength];
1730
- const data = toBuffer(arrayBuffer);
1731
- if (!compress) {
1732
- this._state = DEFAULT;
1733
- this.sendFrame(_Sender.frame(data, options), cb);
1734
- this.dequeue();
1735
- } else {
1736
- this.dispatch(data, compress, options, cb);
1737
- }
1738
- }).catch((err) => {
1739
- process.nextTick(onError, this, err, cb);
1740
- });
1741
- }
1742
- /**
1743
- * Dispatches a message.
1744
- *
1745
- * @param {(Buffer|String)} data The message to send
1746
- * @param {Boolean} [compress=false] Specifies whether or not to compress
1747
- * `data`
1748
- * @param {Object} options Options object
1749
- * @param {Boolean} [options.fin=false] Specifies whether or not to set the
1750
- * FIN bit
1751
- * @param {Function} [options.generateMask] The function used to generate the
1752
- * masking key
1753
- * @param {Boolean} [options.mask=false] Specifies whether or not to mask
1754
- * `data`
1755
- * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
1756
- * key
1757
- * @param {Number} options.opcode The opcode
1758
- * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
1759
- * modified
1760
- * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
1761
- * RSV1 bit
1762
- * @param {Function} [cb] Callback
1763
- * @private
1764
- */
1765
- dispatch(data, compress, options, cb) {
1766
- if (!compress) {
1767
- this.sendFrame(_Sender.frame(data, options), cb);
1768
- return;
1769
- }
1770
- const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
1771
- this._bufferedBytes += options[kByteLength];
1772
- this._state = DEFLATING;
1773
- perMessageDeflate.compress(data, options.fin, (_, buf) => {
1774
- if (this._socket.destroyed) {
1775
- const err = new Error(
1776
- "The socket was closed while data was being compressed"
1777
- );
1778
- callCallbacks(this, err, cb);
1779
- return;
1780
- }
1781
- this._bufferedBytes -= options[kByteLength];
1782
- this._state = DEFAULT;
1783
- options.readOnly = false;
1784
- this.sendFrame(_Sender.frame(buf, options), cb);
1785
- this.dequeue();
1786
- });
1787
- }
1788
- /**
1789
- * Executes queued send operations.
1790
- *
1791
- * @private
1792
- */
1793
- dequeue() {
1794
- while (this._state === DEFAULT && this._queue.length) {
1795
- const params = this._queue.shift();
1796
- this._bufferedBytes -= params[3][kByteLength];
1797
- Reflect.apply(params[0], this, params.slice(1));
1798
- }
1799
- }
1800
- /**
1801
- * Enqueues a send operation.
1802
- *
1803
- * @param {Array} params Send operation parameters.
1804
- * @private
1805
- */
1806
- enqueue(params) {
1807
- this._bufferedBytes += params[3][kByteLength];
1808
- this._queue.push(params);
1809
- }
1810
- /**
1811
- * Sends a frame.
1812
- *
1813
- * @param {(Buffer | String)[]} list The frame to send
1814
- * @param {Function} [cb] Callback
1815
- * @private
1816
- */
1817
- sendFrame(list, cb) {
1818
- if (list.length === 2) {
1819
- this._socket.cork();
1820
- this._socket.write(list[0]);
1821
- this._socket.write(list[1], cb);
1822
- this._socket.uncork();
1823
- } else {
1824
- this._socket.write(list[0], cb);
1825
- }
1826
- }
1827
- };
1828
- module2.exports = Sender2;
1829
- function callCallbacks(sender, err, cb) {
1830
- if (typeof cb === "function") cb(err);
1831
- for (let i = 0; i < sender._queue.length; i++) {
1832
- const params = sender._queue[i];
1833
- const callback = params[params.length - 1];
1834
- if (typeof callback === "function") callback(err);
1835
- }
1836
- }
1837
- function onError(sender, err, cb) {
1838
- callCallbacks(sender, err, cb);
1839
- sender.onerror(err);
1840
- }
1841
- }
1842
- });
1843
-
1844
- // ../../node_modules/ws/lib/event-target.js
1845
- var require_event_target = __commonJS({
1846
- "../../node_modules/ws/lib/event-target.js"(exports2, module2) {
1847
- "use strict";
1848
- var { kForOnEventAttribute, kListener } = require_constants();
1849
- var kCode = Symbol("kCode");
1850
- var kData = Symbol("kData");
1851
- var kError = Symbol("kError");
1852
- var kMessage = Symbol("kMessage");
1853
- var kReason = Symbol("kReason");
1854
- var kTarget = Symbol("kTarget");
1855
- var kType = Symbol("kType");
1856
- var kWasClean = Symbol("kWasClean");
1857
- var Event = class {
1858
- /**
1859
- * Create a new `Event`.
1860
- *
1861
- * @param {String} type The name of the event
1862
- * @throws {TypeError} If the `type` argument is not specified
1863
- */
1864
- constructor(type) {
1865
- this[kTarget] = null;
1866
- this[kType] = type;
1867
- }
1868
- /**
1869
- * @type {*}
1870
- */
1871
- get target() {
1872
- return this[kTarget];
1873
- }
1874
- /**
1875
- * @type {String}
1876
- */
1877
- get type() {
1878
- return this[kType];
1879
- }
1880
- };
1881
- Object.defineProperty(Event.prototype, "target", { enumerable: true });
1882
- Object.defineProperty(Event.prototype, "type", { enumerable: true });
1883
- var CloseEvent = class extends Event {
1884
- /**
1885
- * Create a new `CloseEvent`.
1886
- *
1887
- * @param {String} type The name of the event
1888
- * @param {Object} [options] A dictionary object that allows for setting
1889
- * attributes via object members of the same name
1890
- * @param {Number} [options.code=0] The status code explaining why the
1891
- * connection was closed
1892
- * @param {String} [options.reason=''] A human-readable string explaining why
1893
- * the connection was closed
1894
- * @param {Boolean} [options.wasClean=false] Indicates whether or not the
1895
- * connection was cleanly closed
1896
- */
1897
- constructor(type, options = {}) {
1898
- super(type);
1899
- this[kCode] = options.code === void 0 ? 0 : options.code;
1900
- this[kReason] = options.reason === void 0 ? "" : options.reason;
1901
- this[kWasClean] = options.wasClean === void 0 ? false : options.wasClean;
1902
- }
1903
- /**
1904
- * @type {Number}
1905
- */
1906
- get code() {
1907
- return this[kCode];
1908
- }
1909
- /**
1910
- * @type {String}
1911
- */
1912
- get reason() {
1913
- return this[kReason];
1914
- }
1915
- /**
1916
- * @type {Boolean}
1917
- */
1918
- get wasClean() {
1919
- return this[kWasClean];
1920
- }
1921
- };
1922
- Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
1923
- Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
1924
- Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
1925
- var ErrorEvent = class extends Event {
1926
- /**
1927
- * Create a new `ErrorEvent`.
1928
- *
1929
- * @param {String} type The name of the event
1930
- * @param {Object} [options] A dictionary object that allows for setting
1931
- * attributes via object members of the same name
1932
- * @param {*} [options.error=null] The error that generated this event
1933
- * @param {String} [options.message=''] The error message
1934
- */
1935
- constructor(type, options = {}) {
1936
- super(type);
1937
- this[kError] = options.error === void 0 ? null : options.error;
1938
- this[kMessage] = options.message === void 0 ? "" : options.message;
1939
- }
1940
- /**
1941
- * @type {*}
1942
- */
1943
- get error() {
1944
- return this[kError];
1945
- }
1946
- /**
1947
- * @type {String}
1948
- */
1949
- get message() {
1950
- return this[kMessage];
1951
- }
1952
- };
1953
- Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true });
1954
- Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true });
1955
- var MessageEvent = class extends Event {
1956
- /**
1957
- * Create a new `MessageEvent`.
1958
- *
1959
- * @param {String} type The name of the event
1960
- * @param {Object} [options] A dictionary object that allows for setting
1961
- * attributes via object members of the same name
1962
- * @param {*} [options.data=null] The message content
1963
- */
1964
- constructor(type, options = {}) {
1965
- super(type);
1966
- this[kData] = options.data === void 0 ? null : options.data;
1967
- }
1968
- /**
1969
- * @type {*}
1970
- */
1971
- get data() {
1972
- return this[kData];
1973
- }
1974
- };
1975
- Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
1976
- var EventTarget = {
1977
- /**
1978
- * Register an event listener.
1979
- *
1980
- * @param {String} type A string representing the event type to listen for
1981
- * @param {(Function|Object)} handler The listener to add
1982
- * @param {Object} [options] An options object specifies characteristics about
1983
- * the event listener
1984
- * @param {Boolean} [options.once=false] A `Boolean` indicating that the
1985
- * listener should be invoked at most once after being added. If `true`,
1986
- * the listener would be automatically removed when invoked.
1987
- * @public
1988
- */
1989
- addEventListener(type, handler, options = {}) {
1990
- for (const listener of this.listeners(type)) {
1991
- if (!options[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) {
1992
- return;
1993
- }
1994
- }
1995
- let wrapper;
1996
- if (type === "message") {
1997
- wrapper = function onMessage(data, isBinary) {
1998
- const event = new MessageEvent("message", {
1999
- data: isBinary ? data : data.toString()
2000
- });
2001
- event[kTarget] = this;
2002
- callListener(handler, this, event);
2003
- };
2004
- } else if (type === "close") {
2005
- wrapper = function onClose(code, message) {
2006
- const event = new CloseEvent("close", {
2007
- code,
2008
- reason: message.toString(),
2009
- wasClean: this._closeFrameReceived && this._closeFrameSent
2010
- });
2011
- event[kTarget] = this;
2012
- callListener(handler, this, event);
2013
- };
2014
- } else if (type === "error") {
2015
- wrapper = function onError(error) {
2016
- const event = new ErrorEvent("error", {
2017
- error,
2018
- message: error.message
2019
- });
2020
- event[kTarget] = this;
2021
- callListener(handler, this, event);
2022
- };
2023
- } else if (type === "open") {
2024
- wrapper = function onOpen() {
2025
- const event = new Event("open");
2026
- event[kTarget] = this;
2027
- callListener(handler, this, event);
2028
- };
2029
- } else {
2030
- return;
2031
- }
2032
- wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
2033
- wrapper[kListener] = handler;
2034
- if (options.once) {
2035
- this.once(type, wrapper);
2036
- } else {
2037
- this.on(type, wrapper);
2038
- }
2039
- },
2040
- /**
2041
- * Remove an event listener.
2042
- *
2043
- * @param {String} type A string representing the event type to remove
2044
- * @param {(Function|Object)} handler The listener to remove
2045
- * @public
2046
- */
2047
- removeEventListener(type, handler) {
2048
- for (const listener of this.listeners(type)) {
2049
- if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
2050
- this.removeListener(type, listener);
2051
- break;
2052
- }
2053
- }
2054
- }
2055
- };
2056
- module2.exports = {
2057
- CloseEvent,
2058
- ErrorEvent,
2059
- Event,
2060
- EventTarget,
2061
- MessageEvent
2062
- };
2063
- function callListener(listener, thisArg, event) {
2064
- if (typeof listener === "object" && listener.handleEvent) {
2065
- listener.handleEvent.call(listener, event);
2066
- } else {
2067
- listener.call(thisArg, event);
2068
- }
2069
- }
2070
- }
2071
- });
2072
-
2073
- // ../../node_modules/ws/lib/extension.js
2074
- var require_extension = __commonJS({
2075
- "../../node_modules/ws/lib/extension.js"(exports2, module2) {
2076
- "use strict";
2077
- var { tokenChars } = require_validation();
2078
- function push(dest, name, elem) {
2079
- if (dest[name] === void 0) dest[name] = [elem];
2080
- else dest[name].push(elem);
2081
- }
2082
- function parse(header) {
2083
- const offers = /* @__PURE__ */ Object.create(null);
2084
- let params = /* @__PURE__ */ Object.create(null);
2085
- let mustUnescape = false;
2086
- let isEscaping = false;
2087
- let inQuotes = false;
2088
- let extensionName;
2089
- let paramName;
2090
- let start = -1;
2091
- let code = -1;
2092
- let end = -1;
2093
- let i = 0;
2094
- for (; i < header.length; i++) {
2095
- code = header.charCodeAt(i);
2096
- if (extensionName === void 0) {
2097
- if (end === -1 && tokenChars[code] === 1) {
2098
- if (start === -1) start = i;
2099
- } else if (i !== 0 && (code === 32 || code === 9)) {
2100
- if (end === -1 && start !== -1) end = i;
2101
- } else if (code === 59 || code === 44) {
2102
- if (start === -1) {
2103
- throw new SyntaxError(`Unexpected character at index ${i}`);
2104
- }
2105
- if (end === -1) end = i;
2106
- const name = header.slice(start, end);
2107
- if (code === 44) {
2108
- push(offers, name, params);
2109
- params = /* @__PURE__ */ Object.create(null);
2110
- } else {
2111
- extensionName = name;
2112
- }
2113
- start = end = -1;
2114
- } else {
2115
- throw new SyntaxError(`Unexpected character at index ${i}`);
2116
- }
2117
- } else if (paramName === void 0) {
2118
- if (end === -1 && tokenChars[code] === 1) {
2119
- if (start === -1) start = i;
2120
- } else if (code === 32 || code === 9) {
2121
- if (end === -1 && start !== -1) end = i;
2122
- } else if (code === 59 || code === 44) {
2123
- if (start === -1) {
2124
- throw new SyntaxError(`Unexpected character at index ${i}`);
2125
- }
2126
- if (end === -1) end = i;
2127
- push(params, header.slice(start, end), true);
2128
- if (code === 44) {
2129
- push(offers, extensionName, params);
2130
- params = /* @__PURE__ */ Object.create(null);
2131
- extensionName = void 0;
2132
- }
2133
- start = end = -1;
2134
- } else if (code === 61 && start !== -1 && end === -1) {
2135
- paramName = header.slice(start, i);
2136
- start = end = -1;
2137
- } else {
2138
- throw new SyntaxError(`Unexpected character at index ${i}`);
2139
- }
2140
- } else {
2141
- if (isEscaping) {
2142
- if (tokenChars[code] !== 1) {
2143
- throw new SyntaxError(`Unexpected character at index ${i}`);
2144
- }
2145
- if (start === -1) start = i;
2146
- else if (!mustUnescape) mustUnescape = true;
2147
- isEscaping = false;
2148
- } else if (inQuotes) {
2149
- if (tokenChars[code] === 1) {
2150
- if (start === -1) start = i;
2151
- } else if (code === 34 && start !== -1) {
2152
- inQuotes = false;
2153
- end = i;
2154
- } else if (code === 92) {
2155
- isEscaping = true;
2156
- } else {
2157
- throw new SyntaxError(`Unexpected character at index ${i}`);
2158
- }
2159
- } else if (code === 34 && header.charCodeAt(i - 1) === 61) {
2160
- inQuotes = true;
2161
- } else if (end === -1 && tokenChars[code] === 1) {
2162
- if (start === -1) start = i;
2163
- } else if (start !== -1 && (code === 32 || code === 9)) {
2164
- if (end === -1) end = i;
2165
- } else if (code === 59 || code === 44) {
2166
- if (start === -1) {
2167
- throw new SyntaxError(`Unexpected character at index ${i}`);
2168
- }
2169
- if (end === -1) end = i;
2170
- let value = header.slice(start, end);
2171
- if (mustUnescape) {
2172
- value = value.replace(/\\/g, "");
2173
- mustUnescape = false;
2174
- }
2175
- push(params, paramName, value);
2176
- if (code === 44) {
2177
- push(offers, extensionName, params);
2178
- params = /* @__PURE__ */ Object.create(null);
2179
- extensionName = void 0;
2180
- }
2181
- paramName = void 0;
2182
- start = end = -1;
2183
- } else {
2184
- throw new SyntaxError(`Unexpected character at index ${i}`);
2185
- }
2186
- }
2187
- }
2188
- if (start === -1 || inQuotes || code === 32 || code === 9) {
2189
- throw new SyntaxError("Unexpected end of input");
2190
- }
2191
- if (end === -1) end = i;
2192
- const token = header.slice(start, end);
2193
- if (extensionName === void 0) {
2194
- push(offers, token, params);
2195
- } else {
2196
- if (paramName === void 0) {
2197
- push(params, token, true);
2198
- } else if (mustUnescape) {
2199
- push(params, paramName, token.replace(/\\/g, ""));
2200
- } else {
2201
- push(params, paramName, token);
2202
- }
2203
- push(offers, extensionName, params);
2204
- }
2205
- return offers;
2206
- }
2207
- function format(extensions) {
2208
- return Object.keys(extensions).map((extension) => {
2209
- let configurations = extensions[extension];
2210
- if (!Array.isArray(configurations)) configurations = [configurations];
2211
- return configurations.map((params) => {
2212
- return [extension].concat(
2213
- Object.keys(params).map((k) => {
2214
- let values = params[k];
2215
- if (!Array.isArray(values)) values = [values];
2216
- return values.map((v) => v === true ? k : `${k}=${v}`).join("; ");
2217
- })
2218
- ).join("; ");
2219
- }).join(", ");
2220
- }).join(", ");
2221
- }
2222
- module2.exports = { format, parse };
2223
- }
2224
- });
2225
-
2226
- // ../../node_modules/ws/lib/websocket.js
2227
- var require_websocket = __commonJS({
2228
- "../../node_modules/ws/lib/websocket.js"(exports2, module2) {
2229
- "use strict";
2230
- var EventEmitter = require("events");
2231
- var https = require("https");
2232
- var http = require("http");
2233
- var net = require("net");
2234
- var tls = require("tls");
2235
- var { randomBytes, createHash } = require("crypto");
2236
- var { Duplex, Readable } = require("stream");
2237
- var { URL } = require("url");
2238
- var PerMessageDeflate = require_permessage_deflate();
2239
- var Receiver2 = require_receiver();
2240
- var Sender2 = require_sender();
2241
- var { isBlob } = require_validation();
2242
- var {
2243
- BINARY_TYPES,
2244
- EMPTY_BUFFER,
2245
- GUID,
2246
- kForOnEventAttribute,
2247
- kListener,
2248
- kStatusCode,
2249
- kWebSocket,
2250
- NOOP
2251
- } = require_constants();
2252
- var {
2253
- EventTarget: { addEventListener, removeEventListener }
2254
- } = require_event_target();
2255
- var { format, parse } = require_extension();
2256
- var { toBuffer } = require_buffer_util();
2257
- var closeTimeout = 30 * 1e3;
2258
- var kAborted = Symbol("kAborted");
2259
- var protocolVersions = [8, 13];
2260
- var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
2261
- var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
2262
- var WebSocket2 = class _WebSocket extends EventEmitter {
2263
- /**
2264
- * Create a new `WebSocket`.
2265
- *
2266
- * @param {(String|URL)} address The URL to which to connect
2267
- * @param {(String|String[])} [protocols] The subprotocols
2268
- * @param {Object} [options] Connection options
2269
- */
2270
- constructor(address, protocols, options) {
2271
- super();
2272
- this._binaryType = BINARY_TYPES[0];
2273
- this._closeCode = 1006;
2274
- this._closeFrameReceived = false;
2275
- this._closeFrameSent = false;
2276
- this._closeMessage = EMPTY_BUFFER;
2277
- this._closeTimer = null;
2278
- this._errorEmitted = false;
2279
- this._extensions = {};
2280
- this._paused = false;
2281
- this._protocol = "";
2282
- this._readyState = _WebSocket.CONNECTING;
2283
- this._receiver = null;
2284
- this._sender = null;
2285
- this._socket = null;
2286
- if (address !== null) {
2287
- this._bufferedAmount = 0;
2288
- this._isServer = false;
2289
- this._redirects = 0;
2290
- if (protocols === void 0) {
2291
- protocols = [];
2292
- } else if (!Array.isArray(protocols)) {
2293
- if (typeof protocols === "object" && protocols !== null) {
2294
- options = protocols;
2295
- protocols = [];
2296
- } else {
2297
- protocols = [protocols];
2298
- }
2299
- }
2300
- initAsClient(this, address, protocols, options);
2301
- } else {
2302
- this._autoPong = options.autoPong;
2303
- this._isServer = true;
2304
- }
2305
- }
2306
- /**
2307
- * For historical reasons, the custom "nodebuffer" type is used by the default
2308
- * instead of "blob".
2309
- *
2310
- * @type {String}
2311
- */
2312
- get binaryType() {
2313
- return this._binaryType;
2314
- }
2315
- set binaryType(type) {
2316
- if (!BINARY_TYPES.includes(type)) return;
2317
- this._binaryType = type;
2318
- if (this._receiver) this._receiver._binaryType = type;
2319
- }
2320
- /**
2321
- * @type {Number}
2322
- */
2323
- get bufferedAmount() {
2324
- if (!this._socket) return this._bufferedAmount;
2325
- return this._socket._writableState.length + this._sender._bufferedBytes;
2326
- }
2327
- /**
2328
- * @type {String}
2329
- */
2330
- get extensions() {
2331
- return Object.keys(this._extensions).join();
2332
- }
2333
- /**
2334
- * @type {Boolean}
2335
- */
2336
- get isPaused() {
2337
- return this._paused;
2338
- }
2339
- /**
2340
- * @type {Function}
2341
- */
2342
- /* istanbul ignore next */
2343
- get onclose() {
2344
- return null;
2345
- }
2346
- /**
2347
- * @type {Function}
2348
- */
2349
- /* istanbul ignore next */
2350
- get onerror() {
2351
- return null;
2352
- }
2353
- /**
2354
- * @type {Function}
2355
- */
2356
- /* istanbul ignore next */
2357
- get onopen() {
2358
- return null;
2359
- }
2360
- /**
2361
- * @type {Function}
2362
- */
2363
- /* istanbul ignore next */
2364
- get onmessage() {
2365
- return null;
2366
- }
2367
- /**
2368
- * @type {String}
2369
- */
2370
- get protocol() {
2371
- return this._protocol;
2372
- }
2373
- /**
2374
- * @type {Number}
2375
- */
2376
- get readyState() {
2377
- return this._readyState;
2378
- }
2379
- /**
2380
- * @type {String}
2381
- */
2382
- get url() {
2383
- return this._url;
2384
- }
2385
- /**
2386
- * Set up the socket and the internal resources.
2387
- *
2388
- * @param {Duplex} socket The network socket between the server and client
2389
- * @param {Buffer} head The first packet of the upgraded stream
2390
- * @param {Object} options Options object
2391
- * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
2392
- * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
2393
- * multiple times in the same tick
2394
- * @param {Function} [options.generateMask] The function used to generate the
2395
- * masking key
2396
- * @param {Number} [options.maxPayload=0] The maximum allowed message size
2397
- * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
2398
- * not to skip UTF-8 validation for text and close messages
2399
- * @private
2400
- */
2401
- setSocket(socket, head, options) {
2402
- const receiver = new Receiver2({
2403
- allowSynchronousEvents: options.allowSynchronousEvents,
2404
- binaryType: this.binaryType,
2405
- extensions: this._extensions,
2406
- isServer: this._isServer,
2407
- maxPayload: options.maxPayload,
2408
- skipUTF8Validation: options.skipUTF8Validation
2409
- });
2410
- const sender = new Sender2(socket, this._extensions, options.generateMask);
2411
- this._receiver = receiver;
2412
- this._sender = sender;
2413
- this._socket = socket;
2414
- receiver[kWebSocket] = this;
2415
- sender[kWebSocket] = this;
2416
- socket[kWebSocket] = this;
2417
- receiver.on("conclude", receiverOnConclude);
2418
- receiver.on("drain", receiverOnDrain);
2419
- receiver.on("error", receiverOnError);
2420
- receiver.on("message", receiverOnMessage);
2421
- receiver.on("ping", receiverOnPing);
2422
- receiver.on("pong", receiverOnPong);
2423
- sender.onerror = senderOnError;
2424
- if (socket.setTimeout) socket.setTimeout(0);
2425
- if (socket.setNoDelay) socket.setNoDelay();
2426
- if (head.length > 0) socket.unshift(head);
2427
- socket.on("close", socketOnClose);
2428
- socket.on("data", socketOnData);
2429
- socket.on("end", socketOnEnd);
2430
- socket.on("error", socketOnError);
2431
- this._readyState = _WebSocket.OPEN;
2432
- this.emit("open");
2433
- }
2434
- /**
2435
- * Emit the `'close'` event.
2436
- *
2437
- * @private
2438
- */
2439
- emitClose() {
2440
- if (!this._socket) {
2441
- this._readyState = _WebSocket.CLOSED;
2442
- this.emit("close", this._closeCode, this._closeMessage);
2443
- return;
2444
- }
2445
- if (this._extensions[PerMessageDeflate.extensionName]) {
2446
- this._extensions[PerMessageDeflate.extensionName].cleanup();
2447
- }
2448
- this._receiver.removeAllListeners();
2449
- this._readyState = _WebSocket.CLOSED;
2450
- this.emit("close", this._closeCode, this._closeMessage);
2451
- }
2452
- /**
2453
- * Start a closing handshake.
2454
- *
2455
- * +----------+ +-----------+ +----------+
2456
- * - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
2457
- * | +----------+ +-----------+ +----------+ |
2458
- * +----------+ +-----------+ |
2459
- * CLOSING |ws.close()|<--|close frame|<--+-----+ CLOSING
2460
- * +----------+ +-----------+ |
2461
- * | | | +---+ |
2462
- * +------------------------+-->|fin| - - - -
2463
- * | +---+ | +---+
2464
- * - - - - -|fin|<---------------------+
2465
- * +---+
2466
- *
2467
- * @param {Number} [code] Status code explaining why the connection is closing
2468
- * @param {(String|Buffer)} [data] The reason why the connection is
2469
- * closing
2470
- * @public
2471
- */
2472
- close(code, data) {
2473
- if (this.readyState === _WebSocket.CLOSED) return;
2474
- if (this.readyState === _WebSocket.CONNECTING) {
2475
- const msg = "WebSocket was closed before the connection was established";
2476
- abortHandshake(this, this._req, msg);
2477
- return;
2478
- }
2479
- if (this.readyState === _WebSocket.CLOSING) {
2480
- if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
2481
- this._socket.end();
2482
- }
2483
- return;
2484
- }
2485
- this._readyState = _WebSocket.CLOSING;
2486
- this._sender.close(code, data, !this._isServer, (err) => {
2487
- if (err) return;
2488
- this._closeFrameSent = true;
2489
- if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
2490
- this._socket.end();
2491
- }
2492
- });
2493
- setCloseTimer(this);
2494
- }
2495
- /**
2496
- * Pause the socket.
2497
- *
2498
- * @public
2499
- */
2500
- pause() {
2501
- if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
2502
- return;
2503
- }
2504
- this._paused = true;
2505
- this._socket.pause();
2506
- }
2507
- /**
2508
- * Send a ping.
2509
- *
2510
- * @param {*} [data] The data to send
2511
- * @param {Boolean} [mask] Indicates whether or not to mask `data`
2512
- * @param {Function} [cb] Callback which is executed when the ping is sent
2513
- * @public
2514
- */
2515
- ping(data, mask, cb) {
2516
- if (this.readyState === _WebSocket.CONNECTING) {
2517
- throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
2518
- }
2519
- if (typeof data === "function") {
2520
- cb = data;
2521
- data = mask = void 0;
2522
- } else if (typeof mask === "function") {
2523
- cb = mask;
2524
- mask = void 0;
2525
- }
2526
- if (typeof data === "number") data = data.toString();
2527
- if (this.readyState !== _WebSocket.OPEN) {
2528
- sendAfterClose(this, data, cb);
2529
- return;
2530
- }
2531
- if (mask === void 0) mask = !this._isServer;
2532
- this._sender.ping(data || EMPTY_BUFFER, mask, cb);
2533
- }
2534
- /**
2535
- * Send a pong.
2536
- *
2537
- * @param {*} [data] The data to send
2538
- * @param {Boolean} [mask] Indicates whether or not to mask `data`
2539
- * @param {Function} [cb] Callback which is executed when the pong is sent
2540
- * @public
2541
- */
2542
- pong(data, mask, cb) {
2543
- if (this.readyState === _WebSocket.CONNECTING) {
2544
- throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
2545
- }
2546
- if (typeof data === "function") {
2547
- cb = data;
2548
- data = mask = void 0;
2549
- } else if (typeof mask === "function") {
2550
- cb = mask;
2551
- mask = void 0;
2552
- }
2553
- if (typeof data === "number") data = data.toString();
2554
- if (this.readyState !== _WebSocket.OPEN) {
2555
- sendAfterClose(this, data, cb);
2556
- return;
2557
- }
2558
- if (mask === void 0) mask = !this._isServer;
2559
- this._sender.pong(data || EMPTY_BUFFER, mask, cb);
2560
- }
2561
- /**
2562
- * Resume the socket.
2563
- *
2564
- * @public
2565
- */
2566
- resume() {
2567
- if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
2568
- return;
2569
- }
2570
- this._paused = false;
2571
- if (!this._receiver._writableState.needDrain) this._socket.resume();
2572
- }
2573
- /**
2574
- * Send a data message.
2575
- *
2576
- * @param {*} data The message to send
2577
- * @param {Object} [options] Options object
2578
- * @param {Boolean} [options.binary] Specifies whether `data` is binary or
2579
- * text
2580
- * @param {Boolean} [options.compress] Specifies whether or not to compress
2581
- * `data`
2582
- * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
2583
- * last one
2584
- * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
2585
- * @param {Function} [cb] Callback which is executed when data is written out
2586
- * @public
2587
- */
2588
- send(data, options, cb) {
2589
- if (this.readyState === _WebSocket.CONNECTING) {
2590
- throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
2591
- }
2592
- if (typeof options === "function") {
2593
- cb = options;
2594
- options = {};
2595
- }
2596
- if (typeof data === "number") data = data.toString();
2597
- if (this.readyState !== _WebSocket.OPEN) {
2598
- sendAfterClose(this, data, cb);
2599
- return;
2600
- }
2601
- const opts = {
2602
- binary: typeof data !== "string",
2603
- mask: !this._isServer,
2604
- compress: true,
2605
- fin: true,
2606
- ...options
2607
- };
2608
- if (!this._extensions[PerMessageDeflate.extensionName]) {
2609
- opts.compress = false;
2610
- }
2611
- this._sender.send(data || EMPTY_BUFFER, opts, cb);
2612
- }
2613
- /**
2614
- * Forcibly close the connection.
2615
- *
2616
- * @public
2617
- */
2618
- terminate() {
2619
- if (this.readyState === _WebSocket.CLOSED) return;
2620
- if (this.readyState === _WebSocket.CONNECTING) {
2621
- const msg = "WebSocket was closed before the connection was established";
2622
- abortHandshake(this, this._req, msg);
2623
- return;
2624
- }
2625
- if (this._socket) {
2626
- this._readyState = _WebSocket.CLOSING;
2627
- this._socket.destroy();
2628
- }
2629
- }
2630
- };
2631
- Object.defineProperty(WebSocket2, "CONNECTING", {
2632
- enumerable: true,
2633
- value: readyStates.indexOf("CONNECTING")
2634
- });
2635
- Object.defineProperty(WebSocket2.prototype, "CONNECTING", {
2636
- enumerable: true,
2637
- value: readyStates.indexOf("CONNECTING")
2638
- });
2639
- Object.defineProperty(WebSocket2, "OPEN", {
2640
- enumerable: true,
2641
- value: readyStates.indexOf("OPEN")
2642
- });
2643
- Object.defineProperty(WebSocket2.prototype, "OPEN", {
2644
- enumerable: true,
2645
- value: readyStates.indexOf("OPEN")
2646
- });
2647
- Object.defineProperty(WebSocket2, "CLOSING", {
2648
- enumerable: true,
2649
- value: readyStates.indexOf("CLOSING")
2650
- });
2651
- Object.defineProperty(WebSocket2.prototype, "CLOSING", {
2652
- enumerable: true,
2653
- value: readyStates.indexOf("CLOSING")
2654
- });
2655
- Object.defineProperty(WebSocket2, "CLOSED", {
2656
- enumerable: true,
2657
- value: readyStates.indexOf("CLOSED")
2658
- });
2659
- Object.defineProperty(WebSocket2.prototype, "CLOSED", {
2660
- enumerable: true,
2661
- value: readyStates.indexOf("CLOSED")
2662
- });
2663
- [
2664
- "binaryType",
2665
- "bufferedAmount",
2666
- "extensions",
2667
- "isPaused",
2668
- "protocol",
2669
- "readyState",
2670
- "url"
2671
- ].forEach((property) => {
2672
- Object.defineProperty(WebSocket2.prototype, property, { enumerable: true });
2673
- });
2674
- ["open", "error", "close", "message"].forEach((method) => {
2675
- Object.defineProperty(WebSocket2.prototype, `on${method}`, {
2676
- enumerable: true,
2677
- get() {
2678
- for (const listener of this.listeners(method)) {
2679
- if (listener[kForOnEventAttribute]) return listener[kListener];
2680
- }
2681
- return null;
2682
- },
2683
- set(handler) {
2684
- for (const listener of this.listeners(method)) {
2685
- if (listener[kForOnEventAttribute]) {
2686
- this.removeListener(method, listener);
2687
- break;
2688
- }
2689
- }
2690
- if (typeof handler !== "function") return;
2691
- this.addEventListener(method, handler, {
2692
- [kForOnEventAttribute]: true
2693
- });
2694
- }
2695
- });
2696
- });
2697
- WebSocket2.prototype.addEventListener = addEventListener;
2698
- WebSocket2.prototype.removeEventListener = removeEventListener;
2699
- module2.exports = WebSocket2;
2700
- function initAsClient(websocket, address, protocols, options) {
2701
- const opts = {
2702
- allowSynchronousEvents: true,
2703
- autoPong: true,
2704
- protocolVersion: protocolVersions[1],
2705
- maxPayload: 100 * 1024 * 1024,
2706
- skipUTF8Validation: false,
2707
- perMessageDeflate: true,
2708
- followRedirects: false,
2709
- maxRedirects: 10,
2710
- ...options,
2711
- socketPath: void 0,
2712
- hostname: void 0,
2713
- protocol: void 0,
2714
- timeout: void 0,
2715
- method: "GET",
2716
- host: void 0,
2717
- path: void 0,
2718
- port: void 0
2719
- };
2720
- websocket._autoPong = opts.autoPong;
2721
- if (!protocolVersions.includes(opts.protocolVersion)) {
2722
- throw new RangeError(
2723
- `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
2724
- );
2725
- }
2726
- let parsedUrl;
2727
- if (address instanceof URL) {
2728
- parsedUrl = address;
2729
- } else {
2730
- try {
2731
- parsedUrl = new URL(address);
2732
- } catch (e) {
2733
- throw new SyntaxError(`Invalid URL: ${address}`);
2734
- }
2735
- }
2736
- if (parsedUrl.protocol === "http:") {
2737
- parsedUrl.protocol = "ws:";
2738
- } else if (parsedUrl.protocol === "https:") {
2739
- parsedUrl.protocol = "wss:";
2740
- }
2741
- websocket._url = parsedUrl.href;
2742
- const isSecure = parsedUrl.protocol === "wss:";
2743
- const isIpcUrl = parsedUrl.protocol === "ws+unix:";
2744
- let invalidUrlMessage;
2745
- if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
2746
- invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https:", or "ws+unix:"`;
2747
- } else if (isIpcUrl && !parsedUrl.pathname) {
2748
- invalidUrlMessage = "The URL's pathname is empty";
2749
- } else if (parsedUrl.hash) {
2750
- invalidUrlMessage = "The URL contains a fragment identifier";
2751
- }
2752
- if (invalidUrlMessage) {
2753
- const err = new SyntaxError(invalidUrlMessage);
2754
- if (websocket._redirects === 0) {
2755
- throw err;
2756
- } else {
2757
- emitErrorAndClose(websocket, err);
2758
- return;
2759
- }
2760
- }
2761
- const defaultPort = isSecure ? 443 : 80;
2762
- const key = randomBytes(16).toString("base64");
2763
- const request = isSecure ? https.request : http.request;
2764
- const protocolSet = /* @__PURE__ */ new Set();
2765
- let perMessageDeflate;
2766
- opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
2767
- opts.defaultPort = opts.defaultPort || defaultPort;
2768
- opts.port = parsedUrl.port || defaultPort;
2769
- opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
2770
- opts.headers = {
2771
- ...opts.headers,
2772
- "Sec-WebSocket-Version": opts.protocolVersion,
2773
- "Sec-WebSocket-Key": key,
2774
- Connection: "Upgrade",
2775
- Upgrade: "websocket"
2776
- };
2777
- opts.path = parsedUrl.pathname + parsedUrl.search;
2778
- opts.timeout = opts.handshakeTimeout;
2779
- if (opts.perMessageDeflate) {
2780
- perMessageDeflate = new PerMessageDeflate(
2781
- opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
2782
- false,
2783
- opts.maxPayload
2784
- );
2785
- opts.headers["Sec-WebSocket-Extensions"] = format({
2786
- [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
2787
- });
2788
- }
2789
- if (protocols.length) {
2790
- for (const protocol of protocols) {
2791
- if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) {
2792
- throw new SyntaxError(
2793
- "An invalid or duplicated subprotocol was specified"
2794
- );
2795
- }
2796
- protocolSet.add(protocol);
2797
- }
2798
- opts.headers["Sec-WebSocket-Protocol"] = protocols.join(",");
2799
- }
2800
- if (opts.origin) {
2801
- if (opts.protocolVersion < 13) {
2802
- opts.headers["Sec-WebSocket-Origin"] = opts.origin;
2803
- } else {
2804
- opts.headers.Origin = opts.origin;
2805
- }
2806
- }
2807
- if (parsedUrl.username || parsedUrl.password) {
2808
- opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
2809
- }
2810
- if (isIpcUrl) {
2811
- const parts = opts.path.split(":");
2812
- opts.socketPath = parts[0];
2813
- opts.path = parts[1];
2814
- }
2815
- let req;
2816
- if (opts.followRedirects) {
2817
- if (websocket._redirects === 0) {
2818
- websocket._originalIpc = isIpcUrl;
2819
- websocket._originalSecure = isSecure;
2820
- websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host;
2821
- const headers = options && options.headers;
2822
- options = { ...options, headers: {} };
2823
- if (headers) {
2824
- for (const [key2, value] of Object.entries(headers)) {
2825
- options.headers[key2.toLowerCase()] = value;
2826
- }
2827
- }
2828
- } else if (websocket.listenerCount("redirect") === 0) {
2829
- const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
2830
- if (!isSameHost || websocket._originalSecure && !isSecure) {
2831
- delete opts.headers.authorization;
2832
- delete opts.headers.cookie;
2833
- if (!isSameHost) delete opts.headers.host;
2834
- opts.auth = void 0;
2835
- }
2836
- }
2837
- if (opts.auth && !options.headers.authorization) {
2838
- options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
2839
- }
2840
- req = websocket._req = request(opts);
2841
- if (websocket._redirects) {
2842
- websocket.emit("redirect", websocket.url, req);
2843
- }
2844
- } else {
2845
- req = websocket._req = request(opts);
2846
- }
2847
- if (opts.timeout) {
2848
- req.on("timeout", () => {
2849
- abortHandshake(websocket, req, "Opening handshake has timed out");
2850
- });
2851
- }
2852
- req.on("error", (err) => {
2853
- if (req === null || req[kAborted]) return;
2854
- req = websocket._req = null;
2855
- emitErrorAndClose(websocket, err);
2856
- });
2857
- req.on("response", (res) => {
2858
- const location = res.headers.location;
2859
- const statusCode = res.statusCode;
2860
- if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
2861
- if (++websocket._redirects > opts.maxRedirects) {
2862
- abortHandshake(websocket, req, "Maximum redirects exceeded");
2863
- return;
2864
- }
2865
- req.abort();
2866
- let addr;
2867
- try {
2868
- addr = new URL(location, address);
2869
- } catch (e) {
2870
- const err = new SyntaxError(`Invalid URL: ${location}`);
2871
- emitErrorAndClose(websocket, err);
2872
- return;
2873
- }
2874
- initAsClient(websocket, addr, protocols, options);
2875
- } else if (!websocket.emit("unexpected-response", req, res)) {
2876
- abortHandshake(
2877
- websocket,
2878
- req,
2879
- `Unexpected server response: ${res.statusCode}`
2880
- );
2881
- }
2882
- });
2883
- req.on("upgrade", (res, socket, head) => {
2884
- websocket.emit("upgrade", res);
2885
- if (websocket.readyState !== WebSocket2.CONNECTING) return;
2886
- req = websocket._req = null;
2887
- const upgrade = res.headers.upgrade;
2888
- if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
2889
- abortHandshake(websocket, socket, "Invalid Upgrade header");
2890
- return;
2891
- }
2892
- const digest = createHash("sha1").update(key + GUID).digest("base64");
2893
- if (res.headers["sec-websocket-accept"] !== digest) {
2894
- abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
2895
- return;
2896
- }
2897
- const serverProt = res.headers["sec-websocket-protocol"];
2898
- let protError;
2899
- if (serverProt !== void 0) {
2900
- if (!protocolSet.size) {
2901
- protError = "Server sent a subprotocol but none was requested";
2902
- } else if (!protocolSet.has(serverProt)) {
2903
- protError = "Server sent an invalid subprotocol";
2904
- }
2905
- } else if (protocolSet.size) {
2906
- protError = "Server sent no subprotocol";
2907
- }
2908
- if (protError) {
2909
- abortHandshake(websocket, socket, protError);
2910
- return;
2911
- }
2912
- if (serverProt) websocket._protocol = serverProt;
2913
- const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
2914
- if (secWebSocketExtensions !== void 0) {
2915
- if (!perMessageDeflate) {
2916
- const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested";
2917
- abortHandshake(websocket, socket, message);
2918
- return;
2919
- }
2920
- let extensions;
2921
- try {
2922
- extensions = parse(secWebSocketExtensions);
2923
- } catch (err) {
2924
- const message = "Invalid Sec-WebSocket-Extensions header";
2925
- abortHandshake(websocket, socket, message);
2926
- return;
2927
- }
2928
- const extensionNames = Object.keys(extensions);
2929
- if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
2930
- const message = "Server indicated an extension that was not requested";
2931
- abortHandshake(websocket, socket, message);
2932
- return;
2933
- }
2934
- try {
2935
- perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
2936
- } catch (err) {
2937
- const message = "Invalid Sec-WebSocket-Extensions header";
2938
- abortHandshake(websocket, socket, message);
2939
- return;
2940
- }
2941
- websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
2942
- }
2943
- websocket.setSocket(socket, head, {
2944
- allowSynchronousEvents: opts.allowSynchronousEvents,
2945
- generateMask: opts.generateMask,
2946
- maxPayload: opts.maxPayload,
2947
- skipUTF8Validation: opts.skipUTF8Validation
2948
- });
2949
- });
2950
- if (opts.finishRequest) {
2951
- opts.finishRequest(req, websocket);
2952
- } else {
2953
- req.end();
2954
- }
2955
- }
2956
- function emitErrorAndClose(websocket, err) {
2957
- websocket._readyState = WebSocket2.CLOSING;
2958
- websocket._errorEmitted = true;
2959
- websocket.emit("error", err);
2960
- websocket.emitClose();
2961
- }
2962
- function netConnect(options) {
2963
- options.path = options.socketPath;
2964
- return net.connect(options);
2965
- }
2966
- function tlsConnect(options) {
2967
- options.path = void 0;
2968
- if (!options.servername && options.servername !== "") {
2969
- options.servername = net.isIP(options.host) ? "" : options.host;
2970
- }
2971
- return tls.connect(options);
2972
- }
2973
- function abortHandshake(websocket, stream, message) {
2974
- websocket._readyState = WebSocket2.CLOSING;
2975
- const err = new Error(message);
2976
- Error.captureStackTrace(err, abortHandshake);
2977
- if (stream.setHeader) {
2978
- stream[kAborted] = true;
2979
- stream.abort();
2980
- if (stream.socket && !stream.socket.destroyed) {
2981
- stream.socket.destroy();
2982
- }
2983
- process.nextTick(emitErrorAndClose, websocket, err);
2984
- } else {
2985
- stream.destroy(err);
2986
- stream.once("error", websocket.emit.bind(websocket, "error"));
2987
- stream.once("close", websocket.emitClose.bind(websocket));
2988
- }
2989
- }
2990
- function sendAfterClose(websocket, data, cb) {
2991
- if (data) {
2992
- const length = isBlob(data) ? data.size : toBuffer(data).length;
2993
- if (websocket._socket) websocket._sender._bufferedBytes += length;
2994
- else websocket._bufferedAmount += length;
2995
- }
2996
- if (cb) {
2997
- const err = new Error(
2998
- `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`
2999
- );
3000
- process.nextTick(cb, err);
3001
- }
3002
- }
3003
- function receiverOnConclude(code, reason) {
3004
- const websocket = this[kWebSocket];
3005
- websocket._closeFrameReceived = true;
3006
- websocket._closeMessage = reason;
3007
- websocket._closeCode = code;
3008
- if (websocket._socket[kWebSocket] === void 0) return;
3009
- websocket._socket.removeListener("data", socketOnData);
3010
- process.nextTick(resume, websocket._socket);
3011
- if (code === 1005) websocket.close();
3012
- else websocket.close(code, reason);
3013
- }
3014
- function receiverOnDrain() {
3015
- const websocket = this[kWebSocket];
3016
- if (!websocket.isPaused) websocket._socket.resume();
3017
- }
3018
- function receiverOnError(err) {
3019
- const websocket = this[kWebSocket];
3020
- if (websocket._socket[kWebSocket] !== void 0) {
3021
- websocket._socket.removeListener("data", socketOnData);
3022
- process.nextTick(resume, websocket._socket);
3023
- websocket.close(err[kStatusCode]);
3024
- }
3025
- if (!websocket._errorEmitted) {
3026
- websocket._errorEmitted = true;
3027
- websocket.emit("error", err);
3028
- }
3029
- }
3030
- function receiverOnFinish() {
3031
- this[kWebSocket].emitClose();
3032
- }
3033
- function receiverOnMessage(data, isBinary) {
3034
- this[kWebSocket].emit("message", data, isBinary);
3035
- }
3036
- function receiverOnPing(data) {
3037
- const websocket = this[kWebSocket];
3038
- if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
3039
- websocket.emit("ping", data);
3040
- }
3041
- function receiverOnPong(data) {
3042
- this[kWebSocket].emit("pong", data);
3043
- }
3044
- function resume(stream) {
3045
- stream.resume();
3046
- }
3047
- function senderOnError(err) {
3048
- const websocket = this[kWebSocket];
3049
- if (websocket.readyState === WebSocket2.CLOSED) return;
3050
- if (websocket.readyState === WebSocket2.OPEN) {
3051
- websocket._readyState = WebSocket2.CLOSING;
3052
- setCloseTimer(websocket);
3053
- }
3054
- this._socket.end();
3055
- if (!websocket._errorEmitted) {
3056
- websocket._errorEmitted = true;
3057
- websocket.emit("error", err);
3058
- }
3059
- }
3060
- function setCloseTimer(websocket) {
3061
- websocket._closeTimer = setTimeout(
3062
- websocket._socket.destroy.bind(websocket._socket),
3063
- closeTimeout
3064
- );
3065
- }
3066
- function socketOnClose() {
3067
- const websocket = this[kWebSocket];
3068
- this.removeListener("close", socketOnClose);
3069
- this.removeListener("data", socketOnData);
3070
- this.removeListener("end", socketOnEnd);
3071
- websocket._readyState = WebSocket2.CLOSING;
3072
- let chunk;
3073
- if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
3074
- websocket._receiver.write(chunk);
3075
- }
3076
- websocket._receiver.end();
3077
- this[kWebSocket] = void 0;
3078
- clearTimeout(websocket._closeTimer);
3079
- if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) {
3080
- websocket.emitClose();
3081
- } else {
3082
- websocket._receiver.on("error", receiverOnFinish);
3083
- websocket._receiver.on("finish", receiverOnFinish);
3084
- }
3085
- }
3086
- function socketOnData(chunk) {
3087
- if (!this[kWebSocket]._receiver.write(chunk)) {
3088
- this.pause();
3089
- }
3090
- }
3091
- function socketOnEnd() {
3092
- const websocket = this[kWebSocket];
3093
- websocket._readyState = WebSocket2.CLOSING;
3094
- websocket._receiver.end();
3095
- this.end();
3096
- }
3097
- function socketOnError() {
3098
- const websocket = this[kWebSocket];
3099
- this.removeListener("error", socketOnError);
3100
- this.on("error", NOOP);
3101
- if (websocket) {
3102
- websocket._readyState = WebSocket2.CLOSING;
3103
- this.destroy();
3104
- }
3105
- }
3106
- }
3107
- });
3108
-
3109
- // ../../node_modules/ws/lib/stream.js
3110
- var require_stream = __commonJS({
3111
- "../../node_modules/ws/lib/stream.js"(exports2, module2) {
3112
- "use strict";
3113
- var WebSocket2 = require_websocket();
3114
- var { Duplex } = require("stream");
3115
- function emitClose(stream) {
3116
- stream.emit("close");
3117
- }
3118
- function duplexOnEnd() {
3119
- if (!this.destroyed && this._writableState.finished) {
3120
- this.destroy();
3121
- }
3122
- }
3123
- function duplexOnError(err) {
3124
- this.removeListener("error", duplexOnError);
3125
- this.destroy();
3126
- if (this.listenerCount("error") === 0) {
3127
- this.emit("error", err);
3128
- }
3129
- }
3130
- function createWebSocketStream2(ws, options) {
3131
- let terminateOnDestroy = true;
3132
- const duplex = new Duplex({
3133
- ...options,
3134
- autoDestroy: false,
3135
- emitClose: false,
3136
- objectMode: false,
3137
- writableObjectMode: false
3138
- });
3139
- ws.on("message", function message(msg, isBinary) {
3140
- const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
3141
- if (!duplex.push(data)) ws.pause();
3142
- });
3143
- ws.once("error", function error(err) {
3144
- if (duplex.destroyed) return;
3145
- terminateOnDestroy = false;
3146
- duplex.destroy(err);
3147
- });
3148
- ws.once("close", function close() {
3149
- if (duplex.destroyed) return;
3150
- duplex.push(null);
3151
- });
3152
- duplex._destroy = function(err, callback) {
3153
- if (ws.readyState === ws.CLOSED) {
3154
- callback(err);
3155
- process.nextTick(emitClose, duplex);
3156
- return;
3157
- }
3158
- let called = false;
3159
- ws.once("error", function error(err2) {
3160
- called = true;
3161
- callback(err2);
3162
- });
3163
- ws.once("close", function close() {
3164
- if (!called) callback(err);
3165
- process.nextTick(emitClose, duplex);
3166
- });
3167
- if (terminateOnDestroy) ws.terminate();
3168
- };
3169
- duplex._final = function(callback) {
3170
- if (ws.readyState === ws.CONNECTING) {
3171
- ws.once("open", function open() {
3172
- duplex._final(callback);
3173
- });
3174
- return;
3175
- }
3176
- if (ws._socket === null) return;
3177
- if (ws._socket._writableState.finished) {
3178
- callback();
3179
- if (duplex._readableState.endEmitted) duplex.destroy();
3180
- } else {
3181
- ws._socket.once("finish", function finish() {
3182
- callback();
3183
- });
3184
- ws.close();
3185
- }
3186
- };
3187
- duplex._read = function() {
3188
- if (ws.isPaused) ws.resume();
3189
- };
3190
- duplex._write = function(chunk, encoding, callback) {
3191
- if (ws.readyState === ws.CONNECTING) {
3192
- ws.once("open", function open() {
3193
- duplex._write(chunk, encoding, callback);
3194
- });
3195
- return;
3196
- }
3197
- ws.send(chunk, callback);
3198
- };
3199
- duplex.on("end", duplexOnEnd);
3200
- duplex.on("error", duplexOnError);
3201
- return duplex;
3202
- }
3203
- module2.exports = createWebSocketStream2;
3204
- }
3205
- });
3206
-
3207
- // ../../node_modules/ws/lib/subprotocol.js
3208
- var require_subprotocol = __commonJS({
3209
- "../../node_modules/ws/lib/subprotocol.js"(exports2, module2) {
3210
- "use strict";
3211
- var { tokenChars } = require_validation();
3212
- function parse(header) {
3213
- const protocols = /* @__PURE__ */ new Set();
3214
- let start = -1;
3215
- let end = -1;
3216
- let i = 0;
3217
- for (i; i < header.length; i++) {
3218
- const code = header.charCodeAt(i);
3219
- if (end === -1 && tokenChars[code] === 1) {
3220
- if (start === -1) start = i;
3221
- } else if (i !== 0 && (code === 32 || code === 9)) {
3222
- if (end === -1 && start !== -1) end = i;
3223
- } else if (code === 44) {
3224
- if (start === -1) {
3225
- throw new SyntaxError(`Unexpected character at index ${i}`);
3226
- }
3227
- if (end === -1) end = i;
3228
- const protocol2 = header.slice(start, end);
3229
- if (protocols.has(protocol2)) {
3230
- throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`);
3231
- }
3232
- protocols.add(protocol2);
3233
- start = end = -1;
3234
- } else {
3235
- throw new SyntaxError(`Unexpected character at index ${i}`);
3236
- }
3237
- }
3238
- if (start === -1 || end !== -1) {
3239
- throw new SyntaxError("Unexpected end of input");
3240
- }
3241
- const protocol = header.slice(start, i);
3242
- if (protocols.has(protocol)) {
3243
- throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
3244
- }
3245
- protocols.add(protocol);
3246
- return protocols;
3247
- }
3248
- module2.exports = { parse };
3249
- }
3250
- });
3251
-
3252
- // ../../node_modules/ws/lib/websocket-server.js
3253
- var require_websocket_server = __commonJS({
3254
- "../../node_modules/ws/lib/websocket-server.js"(exports2, module2) {
3255
- "use strict";
3256
- var EventEmitter = require("events");
3257
- var http = require("http");
3258
- var { Duplex } = require("stream");
3259
- var { createHash } = require("crypto");
3260
- var extension = require_extension();
3261
- var PerMessageDeflate = require_permessage_deflate();
3262
- var subprotocol = require_subprotocol();
3263
- var WebSocket2 = require_websocket();
3264
- var { GUID, kWebSocket } = require_constants();
3265
- var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
3266
- var RUNNING = 0;
3267
- var CLOSING = 1;
3268
- var CLOSED = 2;
3269
- var WebSocketServer2 = class extends EventEmitter {
3270
- /**
3271
- * Create a `WebSocketServer` instance.
3272
- *
3273
- * @param {Object} options Configuration options
3274
- * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
3275
- * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
3276
- * multiple times in the same tick
3277
- * @param {Boolean} [options.autoPong=true] Specifies whether or not to
3278
- * automatically send a pong in response to a ping
3279
- * @param {Number} [options.backlog=511] The maximum length of the queue of
3280
- * pending connections
3281
- * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
3282
- * track clients
3283
- * @param {Function} [options.handleProtocols] A hook to handle protocols
3284
- * @param {String} [options.host] The hostname where to bind the server
3285
- * @param {Number} [options.maxPayload=104857600] The maximum allowed message
3286
- * size
3287
- * @param {Boolean} [options.noServer=false] Enable no server mode
3288
- * @param {String} [options.path] Accept only connections matching this path
3289
- * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
3290
- * permessage-deflate
3291
- * @param {Number} [options.port] The port where to bind the server
3292
- * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
3293
- * server to use
3294
- * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
3295
- * not to skip UTF-8 validation for text and close messages
3296
- * @param {Function} [options.verifyClient] A hook to reject connections
3297
- * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
3298
- * class to use. It must be the `WebSocket` class or class that extends it
3299
- * @param {Function} [callback] A listener for the `listening` event
3300
- */
3301
- constructor(options, callback) {
3302
- super();
3303
- options = {
3304
- allowSynchronousEvents: true,
3305
- autoPong: true,
3306
- maxPayload: 100 * 1024 * 1024,
3307
- skipUTF8Validation: false,
3308
- perMessageDeflate: false,
3309
- handleProtocols: null,
3310
- clientTracking: true,
3311
- verifyClient: null,
3312
- noServer: false,
3313
- backlog: null,
3314
- // use default (511 as implemented in net.js)
3315
- server: null,
3316
- host: null,
3317
- path: null,
3318
- port: null,
3319
- WebSocket: WebSocket2,
3320
- ...options
3321
- };
3322
- if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) {
3323
- throw new TypeError(
3324
- 'One and only one of the "port", "server", or "noServer" options must be specified'
3325
- );
3326
- }
3327
- if (options.port != null) {
3328
- this._server = http.createServer((req, res) => {
3329
- const body = http.STATUS_CODES[426];
3330
- res.writeHead(426, {
3331
- "Content-Length": body.length,
3332
- "Content-Type": "text/plain"
3333
- });
3334
- res.end(body);
3335
- });
3336
- this._server.listen(
3337
- options.port,
3338
- options.host,
3339
- options.backlog,
3340
- callback
3341
- );
3342
- } else if (options.server) {
3343
- this._server = options.server;
3344
- }
3345
- if (this._server) {
3346
- const emitConnection = this.emit.bind(this, "connection");
3347
- this._removeListeners = addListeners(this._server, {
3348
- listening: this.emit.bind(this, "listening"),
3349
- error: this.emit.bind(this, "error"),
3350
- upgrade: (req, socket, head) => {
3351
- this.handleUpgrade(req, socket, head, emitConnection);
3352
- }
3353
- });
3354
- }
3355
- if (options.perMessageDeflate === true) options.perMessageDeflate = {};
3356
- if (options.clientTracking) {
3357
- this.clients = /* @__PURE__ */ new Set();
3358
- this._shouldEmitClose = false;
3359
- }
3360
- this.options = options;
3361
- this._state = RUNNING;
3362
- }
3363
- /**
3364
- * Returns the bound address, the address family name, and port of the server
3365
- * as reported by the operating system if listening on an IP socket.
3366
- * If the server is listening on a pipe or UNIX domain socket, the name is
3367
- * returned as a string.
3368
- *
3369
- * @return {(Object|String|null)} The address of the server
3370
- * @public
3371
- */
3372
- address() {
3373
- if (this.options.noServer) {
3374
- throw new Error('The server is operating in "noServer" mode');
3375
- }
3376
- if (!this._server) return null;
3377
- return this._server.address();
3378
- }
3379
- /**
3380
- * Stop the server from accepting new connections and emit the `'close'` event
3381
- * when all existing connections are closed.
3382
- *
3383
- * @param {Function} [cb] A one-time listener for the `'close'` event
3384
- * @public
3385
- */
3386
- close(cb) {
3387
- if (this._state === CLOSED) {
3388
- if (cb) {
3389
- this.once("close", () => {
3390
- cb(new Error("The server is not running"));
3391
- });
3392
- }
3393
- process.nextTick(emitClose, this);
3394
- return;
3395
- }
3396
- if (cb) this.once("close", cb);
3397
- if (this._state === CLOSING) return;
3398
- this._state = CLOSING;
3399
- if (this.options.noServer || this.options.server) {
3400
- if (this._server) {
3401
- this._removeListeners();
3402
- this._removeListeners = this._server = null;
3403
- }
3404
- if (this.clients) {
3405
- if (!this.clients.size) {
3406
- process.nextTick(emitClose, this);
3407
- } else {
3408
- this._shouldEmitClose = true;
3409
- }
3410
- } else {
3411
- process.nextTick(emitClose, this);
3412
- }
3413
- } else {
3414
- const server = this._server;
3415
- this._removeListeners();
3416
- this._removeListeners = this._server = null;
3417
- server.close(() => {
3418
- emitClose(this);
3419
- });
3420
- }
3421
- }
3422
- /**
3423
- * See if a given request should be handled by this server instance.
3424
- *
3425
- * @param {http.IncomingMessage} req Request object to inspect
3426
- * @return {Boolean} `true` if the request is valid, else `false`
3427
- * @public
3428
- */
3429
- shouldHandle(req) {
3430
- if (this.options.path) {
3431
- const index = req.url.indexOf("?");
3432
- const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
3433
- if (pathname !== this.options.path) return false;
3434
- }
3435
- return true;
3436
- }
3437
- /**
3438
- * Handle a HTTP Upgrade request.
3439
- *
3440
- * @param {http.IncomingMessage} req The request object
3441
- * @param {Duplex} socket The network socket between the server and client
3442
- * @param {Buffer} head The first packet of the upgraded stream
3443
- * @param {Function} cb Callback
3444
- * @public
3445
- */
3446
- handleUpgrade(req, socket, head, cb) {
3447
- socket.on("error", socketOnError);
3448
- const key = req.headers["sec-websocket-key"];
3449
- const upgrade = req.headers.upgrade;
3450
- const version = +req.headers["sec-websocket-version"];
3451
- if (req.method !== "GET") {
3452
- const message = "Invalid HTTP method";
3453
- abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
3454
- return;
3455
- }
3456
- if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
3457
- const message = "Invalid Upgrade header";
3458
- abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
3459
- return;
3460
- }
3461
- if (key === void 0 || !keyRegex.test(key)) {
3462
- const message = "Missing or invalid Sec-WebSocket-Key header";
3463
- abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
3464
- return;
3465
- }
3466
- if (version !== 8 && version !== 13) {
3467
- const message = "Missing or invalid Sec-WebSocket-Version header";
3468
- abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
3469
- return;
3470
- }
3471
- if (!this.shouldHandle(req)) {
3472
- abortHandshake(socket, 400);
3473
- return;
3474
- }
3475
- const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
3476
- let protocols = /* @__PURE__ */ new Set();
3477
- if (secWebSocketProtocol !== void 0) {
3478
- try {
3479
- protocols = subprotocol.parse(secWebSocketProtocol);
3480
- } catch (err) {
3481
- const message = "Invalid Sec-WebSocket-Protocol header";
3482
- abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
3483
- return;
3484
- }
3485
- }
3486
- const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
3487
- const extensions = {};
3488
- if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
3489
- const perMessageDeflate = new PerMessageDeflate(
3490
- this.options.perMessageDeflate,
3491
- true,
3492
- this.options.maxPayload
3493
- );
3494
- try {
3495
- const offers = extension.parse(secWebSocketExtensions);
3496
- if (offers[PerMessageDeflate.extensionName]) {
3497
- perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
3498
- extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
3499
- }
3500
- } catch (err) {
3501
- const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
3502
- abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
3503
- return;
3504
- }
3505
- }
3506
- if (this.options.verifyClient) {
3507
- const info = {
3508
- origin: req.headers[`${version === 8 ? "sec-websocket-origin" : "origin"}`],
3509
- secure: !!(req.socket.authorized || req.socket.encrypted),
3510
- req
3511
- };
3512
- if (this.options.verifyClient.length === 2) {
3513
- this.options.verifyClient(info, (verified, code, message, headers) => {
3514
- if (!verified) {
3515
- return abortHandshake(socket, code || 401, message, headers);
3516
- }
3517
- this.completeUpgrade(
3518
- extensions,
3519
- key,
3520
- protocols,
3521
- req,
3522
- socket,
3523
- head,
3524
- cb
3525
- );
3526
- });
3527
- return;
3528
- }
3529
- if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
3530
- }
3531
- this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
3532
- }
3533
- /**
3534
- * Upgrade the connection to WebSocket.
3535
- *
3536
- * @param {Object} extensions The accepted extensions
3537
- * @param {String} key The value of the `Sec-WebSocket-Key` header
3538
- * @param {Set} protocols The subprotocols
3539
- * @param {http.IncomingMessage} req The request object
3540
- * @param {Duplex} socket The network socket between the server and client
3541
- * @param {Buffer} head The first packet of the upgraded stream
3542
- * @param {Function} cb Callback
3543
- * @throws {Error} If called more than once with the same socket
3544
- * @private
3545
- */
3546
- completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
3547
- if (!socket.readable || !socket.writable) return socket.destroy();
3548
- if (socket[kWebSocket]) {
3549
- throw new Error(
3550
- "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
3551
- );
3552
- }
3553
- if (this._state > RUNNING) return abortHandshake(socket, 503);
3554
- const digest = createHash("sha1").update(key + GUID).digest("base64");
3555
- const headers = [
3556
- "HTTP/1.1 101 Switching Protocols",
3557
- "Upgrade: websocket",
3558
- "Connection: Upgrade",
3559
- `Sec-WebSocket-Accept: ${digest}`
3560
- ];
3561
- const ws = new this.options.WebSocket(null, void 0, this.options);
3562
- if (protocols.size) {
3563
- const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value;
3564
- if (protocol) {
3565
- headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
3566
- ws._protocol = protocol;
3567
- }
3568
- }
3569
- if (extensions[PerMessageDeflate.extensionName]) {
3570
- const params = extensions[PerMessageDeflate.extensionName].params;
3571
- const value = extension.format({
3572
- [PerMessageDeflate.extensionName]: [params]
3573
- });
3574
- headers.push(`Sec-WebSocket-Extensions: ${value}`);
3575
- ws._extensions = extensions;
3576
- }
3577
- this.emit("headers", headers, req);
3578
- socket.write(headers.concat("\r\n").join("\r\n"));
3579
- socket.removeListener("error", socketOnError);
3580
- ws.setSocket(socket, head, {
3581
- allowSynchronousEvents: this.options.allowSynchronousEvents,
3582
- maxPayload: this.options.maxPayload,
3583
- skipUTF8Validation: this.options.skipUTF8Validation
3584
- });
3585
- if (this.clients) {
3586
- this.clients.add(ws);
3587
- ws.on("close", () => {
3588
- this.clients.delete(ws);
3589
- if (this._shouldEmitClose && !this.clients.size) {
3590
- process.nextTick(emitClose, this);
3591
- }
3592
- });
3593
- }
3594
- cb(ws, req);
3595
- }
3596
- };
3597
- module2.exports = WebSocketServer2;
3598
- function addListeners(server, map) {
3599
- for (const event of Object.keys(map)) server.on(event, map[event]);
3600
- return function removeListeners() {
3601
- for (const event of Object.keys(map)) {
3602
- server.removeListener(event, map[event]);
3603
- }
3604
- };
3605
- }
3606
- function emitClose(server) {
3607
- server._state = CLOSED;
3608
- server.emit("close");
3609
- }
3610
- function socketOnError() {
3611
- this.destroy();
3612
- }
3613
- function abortHandshake(socket, code, message, headers) {
3614
- message = message || http.STATUS_CODES[code];
3615
- headers = {
3616
- Connection: "close",
3617
- "Content-Type": "text/html",
3618
- "Content-Length": Buffer.byteLength(message),
3619
- ...headers
3620
- };
3621
- socket.once("finish", socket.destroy);
3622
- socket.end(
3623
- `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
3624
- ` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
3625
- );
3626
- }
3627
- function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
3628
- if (server.listenerCount("wsClientError")) {
3629
- const err = new Error(message);
3630
- Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
3631
- server.emit("wsClientError", err, socket, req);
3632
- } else {
3633
- abortHandshake(socket, code, message);
3634
- }
3635
- }
3636
- }
3637
- });
3638
-
3639
- // src/MessageStoreKDB.ts
3640
- var MessageStoreKDB_exports = {};
3641
- __export(MessageStoreKDB_exports, {
3642
- MessageStoreKDB: () => MessageStoreKDB
3643
- });
3644
- module.exports = __toCommonJS(MessageStoreKDB_exports);
3645
- var import_fixparser_common = require("fixparser-common");
3646
-
3647
- // ../../node_modules/ws/wrapper.mjs
3648
- var import_stream = __toESM(require_stream(), 1);
3649
- var import_receiver = __toESM(require_receiver(), 1);
3650
- var import_sender = __toESM(require_sender(), 1);
3651
- var import_websocket = __toESM(require_websocket(), 1);
3652
- var import_websocket_server = __toESM(require_websocket_server(), 1);
3653
-
3654
- // src/c.js
3655
- function u8u16(u16) {
3656
- var u8 = [];
3657
- for (var i = 0; i < u16.length; i++) {
3658
- var c = u16.charCodeAt(i);
3659
- if (c < 128) u8.push(c);
3660
- else if (c < 2048) u8.push(192 | c >> 6, 128 | c & 63);
3661
- else if (c < 55296 || c >= 57344) u8.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
3662
- else {
3663
- c = 65536 + ((c & 1023) << 10 | u16.charCodeAt(++i) & 1023);
3664
- u8.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
3665
- }
3666
- }
3667
- return u8;
3668
- }
3669
- function u16u8(u8) {
3670
- var u16 = "", c, c1, c2;
3671
- for (var i = 0; i < u8.length; i++)
3672
- switch ((c = u8[i]) >> 4) {
3673
- case 0:
3674
- case 1:
3675
- case 2:
3676
- case 3:
3677
- case 4:
3678
- case 5:
3679
- case 6:
3680
- case 7:
3681
- u16 += String.fromCharCode(c);
3682
- break;
3683
- case 12:
3684
- case 13:
3685
- c1 = u8[++i];
3686
- u16 += String.fromCharCode((c & 31) << 6 | c1 & 63);
3687
- break;
3688
- case 14:
3689
- c1 = u8[++i];
3690
- c2 = u8[++i];
3691
- u16 += String.fromCharCode((c & 15) << 12 | (c1 & 63) << 6 | (c2 & 63) << 0);
3692
- break;
3693
- }
3694
- return u16;
3695
- }
3696
- function uncompress(b) {
3697
- b = new Uint8Array(b);
3698
- if (b.length < 12 + 1) {
3699
- return b;
3700
- }
3701
- function i32u8(u8) {
3702
- return new Uint32Array(u8)[0];
3703
- }
3704
- var n = 0, r = 0, f = 0, s = 8, p = s, i = 0, d = 12;
3705
- var usize = i32u8(b.buffer.slice(8, 12));
3706
- var dst = new Uint8Array(usize);
3707
- var aa = new Int32Array(256);
3708
- for (; s < dst.length; ) {
3709
- if (i == 0) {
3710
- f = 255 & b[d++];
3711
- i = 1;
3712
- }
3713
- if ((f & i) != 0) {
3714
- r = aa[255 & b[d++]];
3715
- dst[s++] = dst[r++];
3716
- dst[s++] = dst[r++];
3717
- n = 255 & b[d++];
3718
- for (m = 0; m < n; m++) {
3719
- dst[s + m] = dst[r + m];
3720
- }
3721
- } else {
3722
- dst[s++] = b[d++];
3723
- }
3724
- for (; p < s - 1; ) {
3725
- aa[255 & dst[p] ^ 255 & dst[p + 1]] = p++;
3726
- }
3727
- if ((f & i) != 0) {
3728
- s += n;
3729
- p = s;
3730
- }
3731
- i *= 2;
3732
- if (i == 256) {
3733
- i = 0;
3734
- }
3735
- }
3736
- return dst;
3737
- }
3738
- function compressed(x) {
3739
- return new Uint8Array(x)[2] == 1;
3740
- }
3741
- function deserialize(x) {
3742
- var a = x[0], pos = 8, j2p32 = Math.pow(2, 32), ub = new Uint8Array(x), sb = new Int8Array(x), bb = new Uint8Array(8), hb = new Int16Array(bb.buffer), ib = new Int32Array(bb.buffer), eb = new Float32Array(bb.buffer), fb = new Float64Array(bb.buffer);
3743
- const msDay = 864e5, QEpoch = msDay * 10957;
3744
- function rBool() {
3745
- return rInt8() == 1;
3746
- }
3747
- function rChar() {
3748
- return String.fromCharCode(rInt8());
3749
- }
3750
- function rInt8() {
3751
- return sb[pos++];
3752
- }
3753
- function rNUInt8(n) {
3754
- for (var i = 0; i < n; i++) bb[i] = ub[pos++];
3755
- }
3756
- function rUInt8() {
3757
- return ub[pos++];
3758
- }
3759
- function rGuid() {
3760
- var x2 = "0123456789abcdef", s = "";
3761
- for (var i = 0; i < 16; i++) {
3762
- var c = rUInt8();
3763
- s += i == 4 || i == 6 || i == 8 || i == 10 ? "-" : "";
3764
- s += x2[c >> 4];
3765
- s += x2[c & 15];
3766
- }
3767
- return s;
3768
- }
3769
- function rInt16() {
3770
- rNUInt8(2);
3771
- var h = hb[0];
3772
- return h == -32768 ? NaN : h == -32767 ? -Infinity : h == 32767 ? Infinity : h;
3773
- }
3774
- function rInt32() {
3775
- rNUInt8(4);
3776
- var i = ib[0];
3777
- return i == -2147483648 ? NaN : i == -2147483647 ? -Infinity : i == 2147483647 ? Infinity : i;
3778
- }
3779
- function rInt64() {
3780
- rNUInt8(8);
3781
- var x2 = ib[1], y = ib[0];
3782
- return x2 * j2p32 + (y >= 0 ? y : j2p32 + y);
3783
- }
3784
- function rFloat32() {
3785
- rNUInt8(4);
3786
- return eb[0];
3787
- }
3788
- function rFloat64() {
3789
- rNUInt8(8);
3790
- return fb[0];
3791
- }
3792
- function rSymbol() {
3793
- var i = pos, c, s = [];
3794
- while ((c = rUInt8()) !== 0) s.push(c);
3795
- return u16u8(s);
3796
- }
3797
- ;
3798
- function rTimestamp() {
3799
- return date(rInt64() / 1e6);
3800
- }
3801
- function rMonth() {
3802
- return new Date(Date.UTC(2e3, rInt32(), 1));
3803
- }
3804
- function date(n) {
3805
- return new Date(QEpoch + n);
3806
- }
3807
- function rDate() {
3808
- return date(rInt32() * msDay);
3809
- }
3810
- function rDateTime() {
3811
- return date(rFloat64() * msDay);
3812
- }
3813
- function rTimespan() {
3814
- return date(rInt64() / 1e6);
3815
- }
3816
- function rSecond() {
3817
- return date(rInt32() * 1e3);
3818
- }
3819
- function rMinute() {
3820
- return date(rInt32() * 6e4);
3821
- }
3822
- function rTime() {
3823
- return date(rInt32());
3824
- }
3825
- function r() {
3826
- var fns = [r, rBool, rGuid, null, rUInt8, rInt16, rInt32, rInt64, rFloat32, rFloat64, rChar, rSymbol, rTimestamp, rMonth, rDate, rDateTime, rTimespan, rMinute, rSecond, rTime];
3827
- var i = 0, n, t = rInt8();
3828
- if (t < 0 && t > -20) return fns[-t]();
3829
- if (t > 99) {
3830
- if (t == 100) {
3831
- rSymbol();
3832
- return r();
3833
- }
3834
- if (t < 104) return rInt8() === 0 && t == 101 ? null : "func";
3835
- if (t > 105) r();
3836
- else for (n = rInt32(); i < n; i++) r();
3837
- return "func";
3838
- }
3839
- if (99 == t) {
3840
- var flip = 98 == ub[pos], x2 = r(), y = r(), o;
3841
- if (!flip) {
3842
- o = {};
3843
- for (var i = 0; i < x2.length; i++)
3844
- o[x2[i]] = y[i];
3845
- } else
3846
- o = new Array(2), o[0] = x2, o[1] = y;
3847
- return o;
3848
- }
3849
- pos++;
3850
- if (98 == t) {
3851
- rInt8();
3852
- var x2 = r(), y = r();
3853
- var A = new Array(y[0].length);
3854
- for (var j = 0; j < y[0].length; j++) {
3855
- var o = {};
3856
- for (var i = 0; i < x2.length; i++)
3857
- o[x2[i]] = y[i][j];
3858
- A[j] = o;
3859
- }
3860
- return A;
3861
- }
3862
- n = rInt32();
3863
- if (10 == t) {
3864
- var s = [];
3865
- n += pos;
3866
- for (; pos < n; s.push(rUInt8())) ;
3867
- return u16u8(s);
3868
- }
3869
- var A = new Array(n);
3870
- var f = fns[t];
3871
- for (i = 0; i < n; i++) A[i] = f();
3872
- return A;
3873
- }
3874
- if (compressed(x)) {
3875
- return deserialize(uncompress(ub));
3876
- }
3877
- return r();
3878
- }
3879
- function serialize(x) {
3880
- var a = 1, pos = 0, ub, bb = new Uint8Array(8), ib = new Int32Array(bb.buffer), fb = new Float64Array(bb.buffer);
3881
- function toType(obj) {
3882
- var jsType = typeof obj;
3883
- if (jsType !== "object" && jsType !== "function") return jsType;
3884
- if (!obj) return "null";
3885
- if (obj instanceof Array) return "array";
3886
- if (obj instanceof Date) return "date";
3887
- return "object";
3888
- }
3889
- function getKeys(x2) {
3890
- return Object.keys(x2);
3891
- }
3892
- function getVals(x2) {
3893
- var v = [];
3894
- for (var o in x2) v.push(x2[o]);
3895
- return v;
3896
- }
3897
- function calcN(x2, dt) {
3898
- var t = dt ? dt : toType(x2);
3899
- switch (t) {
3900
- case "null":
3901
- return 2;
3902
- case "object":
3903
- return 1 + calcN(getKeys(x2), "symbols") + calcN(getVals(x2), null);
3904
- case "boolean":
3905
- return 2;
3906
- case "number":
3907
- return 9;
3908
- case "array": {
3909
- var n2 = 6;
3910
- for (var i = 0; i < x2.length; i++) n2 += calcN(x2[i], null);
3911
- return n2;
3912
- }
3913
- case "symbols": {
3914
- var n2 = 6;
3915
- for (var i = 0; i < x2.length; i++) n2 += calcN(x2[i], "symbol");
3916
- return n2;
3917
- }
3918
- case "string":
3919
- return u8u16(x2).length + (x2[0] == "`" ? 1 : 6);
3920
- case "date":
3921
- return 9;
3922
- case "symbol":
3923
- return 2 + u8u16(x2).length;
3924
- }
3925
- throw "bad type " + t;
3926
- }
3927
- function wb(b) {
3928
- ub[pos++] = b;
3929
- }
3930
- function wn(n2) {
3931
- for (var i = 0; i < n2; i++) ub[pos++] = bb[i];
3932
- }
3933
- function w(x2, dt) {
3934
- var t = dt ? dt : toType(x2);
3935
- switch (t) {
3936
- case "null":
3937
- {
3938
- wb(101);
3939
- wb(0);
3940
- }
3941
- break;
3942
- case "boolean":
3943
- {
3944
- wb(-1);
3945
- wb(x2 ? 1 : 0);
3946
- }
3947
- break;
3948
- case "number":
3949
- {
3950
- wb(-9);
3951
- fb[0] = x2;
3952
- wn(8);
3953
- }
3954
- break;
3955
- case "date":
3956
- {
3957
- wb(-15);
3958
- fb[0] = (x2.getTime() - new Date(x2).getTimezoneOffset() * 6e4) / 864e5 - 10957;
3959
- wn(8);
3960
- }
3961
- break;
3962
- case "symbol":
3963
- {
3964
- wb(-11);
3965
- x2 = u8u16(x2);
3966
- for (var i = 0; i < x2.length; i++) wb(x2[i]);
3967
- wb(0);
3968
- }
3969
- break;
3970
- case "string":
3971
- if (x2[0] == "`") {
3972
- w(x2.substr(1), "symbol");
3973
- } else {
3974
- wb(10);
3975
- wb(0);
3976
- x2 = u8u16(x2);
3977
- ib[0] = x2.length;
3978
- wn(4);
3979
- for (var i = 0; i < x2.length; i++) wb(x2[i]);
3980
- }
3981
- break;
3982
- case "object":
3983
- {
3984
- wb(99);
3985
- w(getKeys(x2), "symbols");
3986
- w(getVals(x2), null);
3987
- }
3988
- break;
3989
- case "array":
3990
- {
3991
- wb(0);
3992
- wb(0);
3993
- ib[0] = x2.length;
3994
- wn(4);
3995
- for (var i = 0; i < x2.length; i++) w(x2[i], null);
3996
- }
3997
- break;
3998
- case "symbols":
3999
- {
4000
- wb(0);
4001
- wb(0);
4002
- ib[0] = x2.length;
4003
- wn(4);
4004
- for (var i = 0; i < x2.length; i++) w(x2[i], "symbol");
4005
- }
4006
- break;
4007
- }
4008
- }
4009
- var n = calcN(x, null);
4010
- var ab = new ArrayBuffer(8 + n);
4011
- ub = new Uint8Array(ab);
4012
- wb(1);
4013
- wb(0);
4014
- wb(0);
4015
- wb(0);
4016
- ib[0] = ub.length;
4017
- wn(4);
4018
- w(x, null);
4019
- return ab;
4020
- }
4021
-
4022
- // src/MessageStoreKDB.ts
4023
- var MessageStoreKDB = class {
4024
- /**
4025
- * A number representing the next expected message sequence number.
4026
- * @private
4027
- */
4028
- nextMsgSeqNum = 1;
4029
- inMemoryMessageStore = new import_fixparser_common.MessageBuffer(1048576);
4030
- host;
4031
- port;
4032
- tableName = "FIXParser";
4033
- ws;
4034
- parser;
4035
- logger;
4036
- /* Time in milliseconds between writes to KDB+ */
4037
- writeInterval = 5e3;
4038
- writeIntervalId;
4039
- maxBufferSize;
4040
- constructor({
4041
- host,
4042
- port,
4043
- tableName,
4044
- parser,
4045
- logger,
4046
- onReady,
4047
- maxBufferSize = 2500,
4048
- writeInterval = 5e3
4049
- }) {
4050
- this.host = host;
4051
- this.port = port;
4052
- this.maxBufferSize = maxBufferSize;
4053
- this.writeInterval = writeInterval;
4054
- this.parser = parser;
4055
- if (tableName) this.tableName = tableName;
4056
- if (logger) this.logger = logger;
4057
- this.logger?.log({
4058
- level: "info",
4059
- message: `FIXParser (MessageStoreKDB): -- Connecting to ws://${this.host}:${this.port}...`
4060
- });
4061
- this.ws = new import_websocket.default(`ws://${this.host}:${this.port}`);
4062
- this.ws.binaryType = "arraybuffer";
4063
- this.ws.onopen = async () => {
4064
- this.logger?.log({
4065
- level: "info",
4066
- message: `FIXParser (MessageStoreKDB): -- Successfully opened connection to ws://${this.host}:${this.port}...`
4067
- });
4068
- const tables = await this.sendAsync("tables[]");
4069
- if (tables?.includes(this.tableName)) {
4070
- this.logger?.log({
4071
- level: "info",
4072
- message: `FIXParser (MessageStoreKDB): -- ${this.tableName} table found.`
4073
- });
4074
- onReady();
4075
- } else {
4076
- this.logger?.log({
4077
- level: "info",
4078
- message: "FIXParser (MessageStoreKDB): -- Setting up FIXParser table..."
4079
- });
4080
- this.send(`meta ${this.tableName}:([] msgSequence:\`int$(); message:())`);
4081
- this.send(`\`msgSequence xkey \`${this.tableName}`);
4082
- onReady();
4083
- }
4084
- };
4085
- this.ws.onclose = () => {
4086
- this.logger?.log({
4087
- level: "info",
4088
- message: "FIXParser (MessageStoreKDB): -- Closed"
4089
- });
4090
- this.stopWriteInterval();
4091
- };
4092
- this.ws.onerror = (error) => {
4093
- this.logger?.log({
4094
- level: "error",
4095
- message: "FIXParser (MessageStoreKDB): -- Error:",
4096
- error
4097
- });
4098
- this.stopWriteInterval();
4099
- };
4100
- this.writeIntervalId = setInterval(() => this.writeToKDB(), this.writeInterval);
4101
- }
4102
- send(message) {
4103
- const uuid = (0, import_fixparser_common.uuidv4)().replace(/-/g, "");
4104
- const messageWithUUID = `enlist \`${uuid}, ${message}`;
4105
- if (this.ws.readyState !== import_websocket.default.OPEN) {
4106
- this.logger?.log({
4107
- level: "warn",
4108
- message: `FIXParser (MessageStoreKDB): -- WebSocket not ready! Ignoring command ${message}...`
4109
- });
4110
- }
4111
- this.ws.onmessage = (event) => {
4112
- try {
4113
- const data = deserialize(event.data);
4114
- void data;
4115
- } catch (error) {
4116
- this.logger?.log({
4117
- level: "warn",
4118
- message: `FIXParser (MessageStoreKDB): -- Error parsing response to message id ${uuid}: ${error}`
4119
- });
4120
- }
4121
- };
4122
- this.ws.send(serialize(messageWithUUID));
4123
- }
4124
- sendAsync(message) {
4125
- const uuid = (0, import_fixparser_common.uuidv4)().replace(/-/g, "");
4126
- const messageWithUUID = `enlist \`${uuid}, ${message}`;
4127
- if (this.ws.readyState !== import_websocket.default.OPEN) {
4128
- this.logger?.log({
4129
- level: "warn",
4130
- message: `FIXParser (MessageStoreKDB): -- WebSocket not ready! Ignoring command ${message}...`
4131
- });
4132
- return Promise.resolve(void 0);
4133
- }
4134
- return new Promise((resolve, reject) => {
4135
- this.ws.onmessage = (event) => {
4136
- try {
4137
- const data = deserialize(event.data);
4138
- const receivedUUID = data[0][0];
4139
- const response = data[0].slice(1);
4140
- if (receivedUUID === uuid) {
4141
- resolve(response);
4142
- }
4143
- } catch (error) {
4144
- this.logger?.log({
4145
- level: "warn",
4146
- message: `FIXParser (MessageStoreKDB): -- Error parsing response to message id ${uuid}: ${error}`
4147
- });
4148
- reject(new Error(`Error parsing response to message id ${uuid}`));
4149
- }
4150
- };
4151
- this.ws.send(serialize(messageWithUUID));
4152
- });
4153
- }
4154
- async writeToKDB() {
4155
- const inMemoryMessages = this.inMemoryMessageStore.getAll();
4156
- const clearSequences = [];
4157
- if (inMemoryMessages.length > 0) {
4158
- for (const message of inMemoryMessages) {
4159
- clearSequences.push(message.messageSequence);
4160
- const messageString = message.encode("|");
4161
- const response = await this.sendAsync(
4162
- `\`${this.tableName} upsert (${message.messageSequence}i;"${messageString}")`
4163
- );
4164
- void response;
4165
- }
4166
- for (const seq of clearSequences) {
4167
- this.inMemoryMessageStore.remove(seq);
4168
- }
4169
- }
4170
- }
4171
- add(message) {
4172
- this.inMemoryMessageStore.add(message);
4173
- const bufferLength = this.size();
4174
- if (bufferLength >= this.maxBufferSize) {
4175
- this.writeToKDB();
4176
- }
4177
- }
4178
- getByMsgSequence() {
4179
- throw new Error("Not implemented, please use getByMsgSequenceAsync()");
4180
- }
4181
- async getByMsgSequenceAsync(msgSequence) {
4182
- const getRowById = `select message from ${this.tableName} where msgSequence=${msgSequence}i`;
4183
- const response = await this.sendAsync(getRowById);
4184
- if (response?.length > 0) {
4185
- return this.parser.parse(response[0].message)[0];
4186
- }
4187
- return void 0;
4188
- }
4189
- /**
4190
- * Updates a `Message` instance in the store.
4191
- *
4192
- * @param {number} msgSequence - The sequence number of the message to update.
4193
- * @param {Message} message - The updated message.
4194
- *
4195
- * @returns {boolean} - Returns `true` if the message was updated successfully, `false` otherwise.
4196
- */
4197
- update(msgSequence, message) {
4198
- const updateMessage = `${this.tableName}:${this.tableName} upsert (${msgSequence}i; "${message.encode("|")}")`;
4199
- this.send(updateMessage);
4200
- return true;
4201
- }
4202
- /**
4203
- * Removes a `Message` instance from the store by its sequence number.
4204
- *
4205
- * @param {number} msgSequence - The sequence number of the message to remove.
4206
- *
4207
- * @returns {void}
4208
- */
4209
- remove(msgSequence) {
4210
- this.inMemoryMessageStore.remove(msgSequence);
4211
- const deleteMessage = `delete from ${this.tableName} where msgSequence=${msgSequence}`;
4212
- this.send(deleteMessage);
4213
- }
4214
- /**
4215
- * Checks if a message with a given sequence number exists in the store.
4216
- *
4217
- * @param {number} msgSequence - The sequence number of the message to check.
4218
- * @returns {boolean} - `true` if the message exists, `false` otherwise.
4219
- */
4220
- exists(msgSequence) {
4221
- if (this.inMemoryMessageStore.exists(msgSequence)) {
4222
- return true;
4223
- }
4224
- return false;
4225
- }
4226
- /**
4227
- * Retrieves all `Message` instances from the store.
4228
- *
4229
- * @returns {Message[]} - An array of all `Message` instances in the store.
4230
- */
4231
- getAll() {
4232
- const inMemoryMessages = this.inMemoryMessageStore.getAll();
4233
- return inMemoryMessages;
4234
- }
4235
- /**
4236
- * Retrieves all `Message` instances from the store.
4237
- *
4238
- * @returns {Message[]} - An array of all `Message` instances in the store.
4239
- */
4240
- async getAllAsync() {
4241
- const inMemoryMessages = this.inMemoryMessageStore.getAll();
4242
- if (inMemoryMessages.length > 0) {
4243
- return inMemoryMessages;
4244
- }
4245
- const query = `select from ${this.tableName}`;
4246
- const response = await this.sendAsync(query);
4247
- const messages = [];
4248
- for (const item of response) {
4249
- const message = this.parser.parse(item.message)[0];
4250
- messages.push(message);
4251
- }
4252
- return Promise.resolve(messages);
4253
- }
4254
- size() {
4255
- return this.inMemoryMessageStore.size();
4256
- }
4257
- /**
4258
- * Resizes the message buffer's capacity.
4259
- *
4260
- * @param {number} newCapacity - The new maximum capacity for the buffer.
4261
- * @returns {void}
4262
- */
4263
- resize(newCapacity) {
4264
- this.maxBufferSize = newCapacity;
4265
- }
4266
- clear() {
4267
- this.inMemoryMessageStore.clear();
4268
- this.send(`delete from ${this.tableName}`);
4269
- }
4270
- getCapacity() {
4271
- return this.maxBufferSize;
4272
- }
4273
- stopWriteInterval() {
4274
- clearInterval(this.writeIntervalId);
4275
- }
4276
- /**
4277
- * Set the next message sequence number.
4278
- *
4279
- * @param nextMsgSeqNum - The next message sequence number.
4280
- * @returns {number} - The next message sequence number.
4281
- */
4282
- setNextMsgSeqNum(nextMsgSeqNum) {
4283
- if (nextMsgSeqNum <= 0) {
4284
- throw new Error("Message sequence number must be positive.");
4285
- }
4286
- this.nextMsgSeqNum = nextMsgSeqNum;
4287
- return this.nextMsgSeqNum;
4288
- }
4289
- /**
4290
- * Get the next message sequence number.
4291
- *
4292
- * @returns {number} - The next message sequence number.
4293
- */
4294
- getNextMsgSeqNum() {
4295
- return this.nextMsgSeqNum;
4296
- }
4297
- };
4298
- // Annotate the CommonJS export names for ESM import in node:
4299
- 0 && (module.exports = {
4300
- MessageStoreKDB
4301
- });
1
+ "use strict";var br=Object.create;var xe=Object.defineProperty;var Er=Object.getOwnPropertyDescriptor;var wr=Object.getOwnPropertyNames;var kr=Object.getPrototypeOf,Or=Object.prototype.hasOwnProperty;var N=(t,e)=>()=>(e||t((e={exports:{}}).exports,e),e.exports),Tr=(t,e)=>{for(var r in e)xe(t,r,{get:e[r],enumerable:!0})},lt=(t,e,r,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of wr(e))!Or.call(t,n)&&n!==r&&xe(t,n,{get:()=>e[n],enumerable:!(s=Er(e,n))||s.enumerable});return t};var le=(t,e,r)=>(r=t!=null?br(kr(t)):{},lt(e||!t||!t.__esModule?xe(r,"default",{value:t,enumerable:!0}):r,t)),Nr=t=>lt(xe({},"__esModule",{value:!0}),t);var A=N((tn,ct)=>{"use strict";var ft=["nodebuffer","arraybuffer","fragments"],ht=typeof Blob<"u";ht&&ft.push("blob");ct.exports={BINARY_TYPES:ft,EMPTY_BUFFER:Buffer.alloc(0),GUID:"258EAFA5-E914-47DA-95CA-C5AB0DC85B11",hasBlob:ht,kForOnEventAttribute:Symbol("kIsForOnEventAttribute"),kListener:Symbol("kListener"),kStatusCode:Symbol("status-code"),kWebSocket:Symbol("websocket"),NOOP:()=>{}}});var fe=N((rn,be)=>{"use strict";var{EMPTY_BUFFER:Cr}=A(),Re=Buffer[Symbol.species];function Ir(t,e){if(t.length===0)return Cr;if(t.length===1)return t[0];let r=Buffer.allocUnsafe(e),s=0;for(let n=0;n<t.length;n++){let i=t[n];r.set(i,s),s+=i.length}return s<e?new Re(r.buffer,r.byteOffset,s):r}function ut(t,e,r,s,n){for(let i=0;i<n;i++)r[s+i]=t[i]^e[i&3]}function dt(t,e){for(let r=0;r<t.length;r++)t[r]^=e[r&3]}function Lr(t){return t.length===t.buffer.byteLength?t.buffer:t.buffer.slice(t.byteOffset,t.byteOffset+t.length)}function Fe(t){if(Fe.readOnly=!0,Buffer.isBuffer(t))return t;let e;return t instanceof ArrayBuffer?e=new Re(t):ArrayBuffer.isView(t)?e=new Re(t.buffer,t.byteOffset,t.byteLength):(e=Buffer.from(t),Fe.readOnly=!1),e}be.exports={concat:Ir,mask:ut,toArrayBuffer:Lr,toBuffer:Fe,unmask:dt};if(!process.env.WS_NO_BUFFER_UTIL)try{let t=require("bufferutil");be.exports.mask=function(e,r,s,n,i){i<48?ut(e,r,s,n,i):t.mask(e,r,s,n,i)},be.exports.unmask=function(e,r){e.length<32?dt(e,r):t.unmask(e,r)}}catch{}});var pt=N((sn,mt)=>{"use strict";var _t=Symbol("kDone"),We=Symbol("kRun"),$e=class{constructor(e){this[_t]=()=>{this.pending--,this[We]()},this.concurrency=e||1/0,this.jobs=[],this.pending=0}add(e){this.jobs.push(e),this[We]()}[We](){if(this.pending!==this.concurrency&&this.jobs.length){let e=this.jobs.shift();this.pending++,e(this[_t])}}};mt.exports=$e});var ce=N((nn,vt)=>{"use strict";var he=require("zlib"),gt=fe(),Mr=pt(),{kStatusCode:yt}=A(),Pr=Buffer[Symbol.species],Br=Buffer.from([0,0,255,255]),we=Symbol("permessage-deflate"),R=Symbol("total-length"),Q=Symbol("callback"),$=Symbol("buffers"),J=Symbol("error"),Ee,qe=class{constructor(e,r,s){if(this._maxPayload=s|0,this._options=e||{},this._threshold=this._options.threshold!==void 0?this._options.threshold:1024,this._isServer=!!r,this._deflate=null,this._inflate=null,this.params=null,!Ee){let n=this._options.concurrencyLimit!==void 0?this._options.concurrencyLimit:10;Ee=new Mr(n)}}static get extensionName(){return"permessage-deflate"}offer(){let e={};return this._options.serverNoContextTakeover&&(e.server_no_context_takeover=!0),this._options.clientNoContextTakeover&&(e.client_no_context_takeover=!0),this._options.serverMaxWindowBits&&(e.server_max_window_bits=this._options.serverMaxWindowBits),this._options.clientMaxWindowBits?e.client_max_window_bits=this._options.clientMaxWindowBits:this._options.clientMaxWindowBits==null&&(e.client_max_window_bits=!0),e}accept(e){return e=this.normalizeParams(e),this.params=this._isServer?this.acceptAsServer(e):this.acceptAsClient(e),this.params}cleanup(){if(this._inflate&&(this._inflate.close(),this._inflate=null),this._deflate){let e=this._deflate[Q];this._deflate.close(),this._deflate=null,e&&e(new Error("The deflate stream was closed while data was being processed"))}}acceptAsServer(e){let r=this._options,s=e.find(n=>!(r.serverNoContextTakeover===!1&&n.server_no_context_takeover||n.server_max_window_bits&&(r.serverMaxWindowBits===!1||typeof r.serverMaxWindowBits=="number"&&r.serverMaxWindowBits>n.server_max_window_bits)||typeof r.clientMaxWindowBits=="number"&&!n.client_max_window_bits));if(!s)throw new Error("None of the extension offers can be accepted");return r.serverNoContextTakeover&&(s.server_no_context_takeover=!0),r.clientNoContextTakeover&&(s.client_no_context_takeover=!0),typeof r.serverMaxWindowBits=="number"&&(s.server_max_window_bits=r.serverMaxWindowBits),typeof r.clientMaxWindowBits=="number"?s.client_max_window_bits=r.clientMaxWindowBits:(s.client_max_window_bits===!0||r.clientMaxWindowBits===!1)&&delete s.client_max_window_bits,s}acceptAsClient(e){let r=e[0];if(this._options.clientNoContextTakeover===!1&&r.client_no_context_takeover)throw new Error('Unexpected parameter "client_no_context_takeover"');if(!r.client_max_window_bits)typeof this._options.clientMaxWindowBits=="number"&&(r.client_max_window_bits=this._options.clientMaxWindowBits);else if(this._options.clientMaxWindowBits===!1||typeof this._options.clientMaxWindowBits=="number"&&r.client_max_window_bits>this._options.clientMaxWindowBits)throw new Error('Unexpected or invalid parameter "client_max_window_bits"');return r}normalizeParams(e){return e.forEach(r=>{Object.keys(r).forEach(s=>{let n=r[s];if(n.length>1)throw new Error(`Parameter "${s}" must have only a single value`);if(n=n[0],s==="client_max_window_bits"){if(n!==!0){let i=+n;if(!Number.isInteger(i)||i<8||i>15)throw new TypeError(`Invalid value for parameter "${s}": ${n}`);n=i}else if(!this._isServer)throw new TypeError(`Invalid value for parameter "${s}": ${n}`)}else if(s==="server_max_window_bits"){let i=+n;if(!Number.isInteger(i)||i<8||i>15)throw new TypeError(`Invalid value for parameter "${s}": ${n}`);n=i}else if(s==="client_no_context_takeover"||s==="server_no_context_takeover"){if(n!==!0)throw new TypeError(`Invalid value for parameter "${s}": ${n}`)}else throw new Error(`Unknown parameter "${s}"`);r[s]=n})}),e}decompress(e,r,s){Ee.add(n=>{this._decompress(e,r,(i,o)=>{n(),s(i,o)})})}compress(e,r,s){Ee.add(n=>{this._compress(e,r,(i,o)=>{n(),s(i,o)})})}_decompress(e,r,s){let n=this._isServer?"client":"server";if(!this._inflate){let i=`${n}_max_window_bits`,o=typeof this.params[i]!="number"?he.Z_DEFAULT_WINDOWBITS:this.params[i];this._inflate=he.createInflateRaw({...this._options.zlibInflateOptions,windowBits:o}),this._inflate[we]=this,this._inflate[R]=0,this._inflate[$]=[],this._inflate.on("error",Ur),this._inflate.on("data",St)}this._inflate[Q]=s,this._inflate.write(e),r&&this._inflate.write(Br),this._inflate.flush(()=>{let i=this._inflate[J];if(i){this._inflate.close(),this._inflate=null,s(i);return}let o=gt.concat(this._inflate[$],this._inflate[R]);this._inflate._readableState.endEmitted?(this._inflate.close(),this._inflate=null):(this._inflate[R]=0,this._inflate[$]=[],r&&this.params[`${n}_no_context_takeover`]&&this._inflate.reset()),s(null,o)})}_compress(e,r,s){let n=this._isServer?"server":"client";if(!this._deflate){let i=`${n}_max_window_bits`,o=typeof this.params[i]!="number"?he.Z_DEFAULT_WINDOWBITS:this.params[i];this._deflate=he.createDeflateRaw({...this._options.zlibDeflateOptions,windowBits:o}),this._deflate[R]=0,this._deflate[$]=[],this._deflate.on("data",Dr)}this._deflate[Q]=s,this._deflate.write(e),this._deflate.flush(he.Z_SYNC_FLUSH,()=>{if(!this._deflate)return;let i=gt.concat(this._deflate[$],this._deflate[R]);r&&(i=new Pr(i.buffer,i.byteOffset,i.length-4)),this._deflate[Q]=null,this._deflate[R]=0,this._deflate[$]=[],r&&this.params[`${n}_no_context_takeover`]&&this._deflate.reset(),s(null,i)})}};vt.exports=qe;function Dr(t){this[$].push(t),this[R]+=t.length}function St(t){if(this[R]+=t.length,this[we]._maxPayload<1||this[R]<=this[we]._maxPayload){this[$].push(t);return}this[J]=new RangeError("Max payload size exceeded"),this[J].code="WS_ERR_UNSUPPORTED_MESSAGE_LENGTH",this[J][yt]=1009,this.removeListener("data",St),this.reset()}function Ur(t){if(this[we]._inflate=null,this[J]){this[Q](this[J]);return}t[yt]=1007,this[Q](t)}});var ee=N((on,ke)=>{"use strict";var{isUtf8:xt}=require("buffer"),{hasBlob:Ar}=A(),Rr=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1,0,0,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0];function Fr(t){return t>=1e3&&t<=1014&&t!==1004&&t!==1005&&t!==1006||t>=3e3&&t<=4999}function Ge(t){let e=t.length,r=0;for(;r<e;)if((t[r]&128)===0)r++;else if((t[r]&224)===192){if(r+1===e||(t[r+1]&192)!==128||(t[r]&254)===192)return!1;r+=2}else if((t[r]&240)===224){if(r+2>=e||(t[r+1]&192)!==128||(t[r+2]&192)!==128||t[r]===224&&(t[r+1]&224)===128||t[r]===237&&(t[r+1]&224)===160)return!1;r+=3}else if((t[r]&248)===240){if(r+3>=e||(t[r+1]&192)!==128||(t[r+2]&192)!==128||(t[r+3]&192)!==128||t[r]===240&&(t[r+1]&240)===128||t[r]===244&&t[r+1]>143||t[r]>244)return!1;r+=4}else return!1;return!0}function Wr(t){return Ar&&typeof t=="object"&&typeof t.arrayBuffer=="function"&&typeof t.type=="string"&&typeof t.stream=="function"&&(t[Symbol.toStringTag]==="Blob"||t[Symbol.toStringTag]==="File")}ke.exports={isBlob:Wr,isValidStatusCode:Fr,isValidUTF8:Ge,tokenChars:Rr};if(xt)ke.exports.isValidUTF8=function(t){return t.length<24?Ge(t):xt(t)};else if(!process.env.WS_NO_UTF_8_VALIDATE)try{let t=require("utf-8-validate");ke.exports.isValidUTF8=function(e){return e.length<32?Ge(e):t(e)}}catch{}});var Ke=N((an,Nt)=>{"use strict";var{Writable:$r}=require("stream"),bt=ce(),{BINARY_TYPES:qr,EMPTY_BUFFER:Et,kStatusCode:Gr,kWebSocket:jr}=A(),{concat:je,toArrayBuffer:Vr,unmask:zr}=fe(),{isValidStatusCode:Hr,isValidUTF8:wt}=ee(),Oe=Buffer[Symbol.species],I=0,kt=1,Ot=2,Tt=3,Ve=4,ze=5,Te=6,He=class extends $r{constructor(e={}){super(),this._allowSynchronousEvents=e.allowSynchronousEvents!==void 0?e.allowSynchronousEvents:!0,this._binaryType=e.binaryType||qr[0],this._extensions=e.extensions||{},this._isServer=!!e.isServer,this._maxPayload=e.maxPayload|0,this._skipUTF8Validation=!!e.skipUTF8Validation,this[jr]=void 0,this._bufferedBytes=0,this._buffers=[],this._compressed=!1,this._payloadLength=0,this._mask=void 0,this._fragmented=0,this._masked=!1,this._fin=!1,this._opcode=0,this._totalPayloadLength=0,this._messageLength=0,this._fragments=[],this._errored=!1,this._loop=!1,this._state=I}_write(e,r,s){if(this._opcode===8&&this._state==I)return s();this._bufferedBytes+=e.length,this._buffers.push(e),this.startLoop(s)}consume(e){if(this._bufferedBytes-=e,e===this._buffers[0].length)return this._buffers.shift();if(e<this._buffers[0].length){let s=this._buffers[0];return this._buffers[0]=new Oe(s.buffer,s.byteOffset+e,s.length-e),new Oe(s.buffer,s.byteOffset,e)}let r=Buffer.allocUnsafe(e);do{let s=this._buffers[0],n=r.length-e;e>=s.length?r.set(this._buffers.shift(),n):(r.set(new Uint8Array(s.buffer,s.byteOffset,e),n),this._buffers[0]=new Oe(s.buffer,s.byteOffset+e,s.length-e)),e-=s.length}while(e>0);return r}startLoop(e){this._loop=!0;do switch(this._state){case I:this.getInfo(e);break;case kt:this.getPayloadLength16(e);break;case Ot:this.getPayloadLength64(e);break;case Tt:this.getMask();break;case Ve:this.getData(e);break;case ze:case Te:this._loop=!1;return}while(this._loop);this._errored||e()}getInfo(e){if(this._bufferedBytes<2){this._loop=!1;return}let r=this.consume(2);if((r[0]&48)!==0){let n=this.createError(RangeError,"RSV2 and RSV3 must be clear",!0,1002,"WS_ERR_UNEXPECTED_RSV_2_3");e(n);return}let s=(r[0]&64)===64;if(s&&!this._extensions[bt.extensionName]){let n=this.createError(RangeError,"RSV1 must be clear",!0,1002,"WS_ERR_UNEXPECTED_RSV_1");e(n);return}if(this._fin=(r[0]&128)===128,this._opcode=r[0]&15,this._payloadLength=r[1]&127,this._opcode===0){if(s){let n=this.createError(RangeError,"RSV1 must be clear",!0,1002,"WS_ERR_UNEXPECTED_RSV_1");e(n);return}if(!this._fragmented){let n=this.createError(RangeError,"invalid opcode 0",!0,1002,"WS_ERR_INVALID_OPCODE");e(n);return}this._opcode=this._fragmented}else if(this._opcode===1||this._opcode===2){if(this._fragmented){let n=this.createError(RangeError,`invalid opcode ${this._opcode}`,!0,1002,"WS_ERR_INVALID_OPCODE");e(n);return}this._compressed=s}else if(this._opcode>7&&this._opcode<11){if(!this._fin){let n=this.createError(RangeError,"FIN must be set",!0,1002,"WS_ERR_EXPECTED_FIN");e(n);return}if(s){let n=this.createError(RangeError,"RSV1 must be clear",!0,1002,"WS_ERR_UNEXPECTED_RSV_1");e(n);return}if(this._payloadLength>125||this._opcode===8&&this._payloadLength===1){let n=this.createError(RangeError,`invalid payload length ${this._payloadLength}`,!0,1002,"WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH");e(n);return}}else{let n=this.createError(RangeError,`invalid opcode ${this._opcode}`,!0,1002,"WS_ERR_INVALID_OPCODE");e(n);return}if(!this._fin&&!this._fragmented&&(this._fragmented=this._opcode),this._masked=(r[1]&128)===128,this._isServer){if(!this._masked){let n=this.createError(RangeError,"MASK must be set",!0,1002,"WS_ERR_EXPECTED_MASK");e(n);return}}else if(this._masked){let n=this.createError(RangeError,"MASK must be clear",!0,1002,"WS_ERR_UNEXPECTED_MASK");e(n);return}this._payloadLength===126?this._state=kt:this._payloadLength===127?this._state=Ot:this.haveLength(e)}getPayloadLength16(e){if(this._bufferedBytes<2){this._loop=!1;return}this._payloadLength=this.consume(2).readUInt16BE(0),this.haveLength(e)}getPayloadLength64(e){if(this._bufferedBytes<8){this._loop=!1;return}let r=this.consume(8),s=r.readUInt32BE(0);if(s>Math.pow(2,21)-1){let n=this.createError(RangeError,"Unsupported WebSocket frame: payload length > 2^53 - 1",!1,1009,"WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH");e(n);return}this._payloadLength=s*Math.pow(2,32)+r.readUInt32BE(4),this.haveLength(e)}haveLength(e){if(this._payloadLength&&this._opcode<8&&(this._totalPayloadLength+=this._payloadLength,this._totalPayloadLength>this._maxPayload&&this._maxPayload>0)){let r=this.createError(RangeError,"Max payload size exceeded",!1,1009,"WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");e(r);return}this._masked?this._state=Tt:this._state=Ve}getMask(){if(this._bufferedBytes<4){this._loop=!1;return}this._mask=this.consume(4),this._state=Ve}getData(e){let r=Et;if(this._payloadLength){if(this._bufferedBytes<this._payloadLength){this._loop=!1;return}r=this.consume(this._payloadLength),this._masked&&(this._mask[0]|this._mask[1]|this._mask[2]|this._mask[3])!==0&&zr(r,this._mask)}if(this._opcode>7){this.controlMessage(r,e);return}if(this._compressed){this._state=ze,this.decompress(r,e);return}r.length&&(this._messageLength=this._totalPayloadLength,this._fragments.push(r)),this.dataMessage(e)}decompress(e,r){this._extensions[bt.extensionName].decompress(e,this._fin,(n,i)=>{if(n)return r(n);if(i.length){if(this._messageLength+=i.length,this._messageLength>this._maxPayload&&this._maxPayload>0){let o=this.createError(RangeError,"Max payload size exceeded",!1,1009,"WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");r(o);return}this._fragments.push(i)}this.dataMessage(r),this._state===I&&this.startLoop(r)})}dataMessage(e){if(!this._fin){this._state=I;return}let r=this._messageLength,s=this._fragments;if(this._totalPayloadLength=0,this._messageLength=0,this._fragmented=0,this._fragments=[],this._opcode===2){let n;this._binaryType==="nodebuffer"?n=je(s,r):this._binaryType==="arraybuffer"?n=Vr(je(s,r)):this._binaryType==="blob"?n=new Blob(s):n=s,this._allowSynchronousEvents?(this.emit("message",n,!0),this._state=I):(this._state=Te,setImmediate(()=>{this.emit("message",n,!0),this._state=I,this.startLoop(e)}))}else{let n=je(s,r);if(!this._skipUTF8Validation&&!wt(n)){let i=this.createError(Error,"invalid UTF-8 sequence",!0,1007,"WS_ERR_INVALID_UTF8");e(i);return}this._state===ze||this._allowSynchronousEvents?(this.emit("message",n,!1),this._state=I):(this._state=Te,setImmediate(()=>{this.emit("message",n,!1),this._state=I,this.startLoop(e)}))}}controlMessage(e,r){if(this._opcode===8){if(e.length===0)this._loop=!1,this.emit("conclude",1005,Et),this.end();else{let s=e.readUInt16BE(0);if(!Hr(s)){let i=this.createError(RangeError,`invalid status code ${s}`,!0,1002,"WS_ERR_INVALID_CLOSE_CODE");r(i);return}let n=new Oe(e.buffer,e.byteOffset+2,e.length-2);if(!this._skipUTF8Validation&&!wt(n)){let i=this.createError(Error,"invalid UTF-8 sequence",!0,1007,"WS_ERR_INVALID_UTF8");r(i);return}this._loop=!1,this.emit("conclude",s,n),this.end()}this._state=I;return}this._allowSynchronousEvents?(this.emit(this._opcode===9?"ping":"pong",e),this._state=I):(this._state=Te,setImmediate(()=>{this.emit(this._opcode===9?"ping":"pong",e),this._state=I,this.startLoop(r)}))}createError(e,r,s,n,i){this._loop=!1,this._errored=!0;let o=new e(s?`Invalid WebSocket frame: ${r}`:r);return Error.captureStackTrace(o,this.createError),o.code=i,o[Gr]=n,o}};Nt.exports=He});var Ze=N((fn,Lt)=>{"use strict";var{Duplex:ln}=require("stream"),{randomFillSync:Kr}=require("crypto"),Ct=ce(),{EMPTY_BUFFER:Xr,kWebSocket:Yr,NOOP:Zr}=A(),{isBlob:te,isValidStatusCode:Qr}=ee(),{mask:It,toBuffer:j}=fe(),L=Symbol("kByteLength"),Jr=Buffer.alloc(4),Ne=8*1024,V,re=Ne,M=0,es=1,ts=2,Xe=class t{constructor(e,r,s){this._extensions=r||{},s&&(this._generateMask=s,this._maskBuffer=Buffer.alloc(4)),this._socket=e,this._firstFragment=!0,this._compress=!1,this._bufferedBytes=0,this._queue=[],this._state=M,this.onerror=Zr,this[Yr]=void 0}static frame(e,r){let s,n=!1,i=2,o=!1;r.mask&&(s=r.maskBuffer||Jr,r.generateMask?r.generateMask(s):(re===Ne&&(V===void 0&&(V=Buffer.alloc(Ne)),Kr(V,0,Ne),re=0),s[0]=V[re++],s[1]=V[re++],s[2]=V[re++],s[3]=V[re++]),o=(s[0]|s[1]|s[2]|s[3])===0,i=6);let a;typeof e=="string"?(!r.mask||o)&&r[L]!==void 0?a=r[L]:(e=Buffer.from(e),a=e.length):(a=e.length,n=r.mask&&r.readOnly&&!o);let h=a;a>=65536?(i+=8,h=127):a>125&&(i+=2,h=126);let l=Buffer.allocUnsafe(n?a+i:i);return l[0]=r.fin?r.opcode|128:r.opcode,r.rsv1&&(l[0]|=64),l[1]=h,h===126?l.writeUInt16BE(a,2):h===127&&(l[2]=l[3]=0,l.writeUIntBE(a,4,6)),r.mask?(l[1]|=128,l[i-4]=s[0],l[i-3]=s[1],l[i-2]=s[2],l[i-1]=s[3],o?[l,e]:n?(It(e,s,l,i,a),[l]):(It(e,s,e,0,a),[l,e])):[l,e]}close(e,r,s,n){let i;if(e===void 0)i=Xr;else{if(typeof e!="number"||!Qr(e))throw new TypeError("First argument must be a valid error code number");if(r===void 0||!r.length)i=Buffer.allocUnsafe(2),i.writeUInt16BE(e,0);else{let a=Buffer.byteLength(r);if(a>123)throw new RangeError("The message must not be greater than 123 bytes");i=Buffer.allocUnsafe(2+a),i.writeUInt16BE(e,0),typeof r=="string"?i.write(r,2):i.set(r,2)}}let o={[L]:i.length,fin:!0,generateMask:this._generateMask,mask:s,maskBuffer:this._maskBuffer,opcode:8,readOnly:!1,rsv1:!1};this._state!==M?this.enqueue([this.dispatch,i,!1,o,n]):this.sendFrame(t.frame(i,o),n)}ping(e,r,s){let n,i;if(typeof e=="string"?(n=Buffer.byteLength(e),i=!1):te(e)?(n=e.size,i=!1):(e=j(e),n=e.length,i=j.readOnly),n>125)throw new RangeError("The data size must not be greater than 125 bytes");let o={[L]:n,fin:!0,generateMask:this._generateMask,mask:r,maskBuffer:this._maskBuffer,opcode:9,readOnly:i,rsv1:!1};te(e)?this._state!==M?this.enqueue([this.getBlobData,e,!1,o,s]):this.getBlobData(e,!1,o,s):this._state!==M?this.enqueue([this.dispatch,e,!1,o,s]):this.sendFrame(t.frame(e,o),s)}pong(e,r,s){let n,i;if(typeof e=="string"?(n=Buffer.byteLength(e),i=!1):te(e)?(n=e.size,i=!1):(e=j(e),n=e.length,i=j.readOnly),n>125)throw new RangeError("The data size must not be greater than 125 bytes");let o={[L]:n,fin:!0,generateMask:this._generateMask,mask:r,maskBuffer:this._maskBuffer,opcode:10,readOnly:i,rsv1:!1};te(e)?this._state!==M?this.enqueue([this.getBlobData,e,!1,o,s]):this.getBlobData(e,!1,o,s):this._state!==M?this.enqueue([this.dispatch,e,!1,o,s]):this.sendFrame(t.frame(e,o),s)}send(e,r,s){let n=this._extensions[Ct.extensionName],i=r.binary?2:1,o=r.compress,a,h;typeof e=="string"?(a=Buffer.byteLength(e),h=!1):te(e)?(a=e.size,h=!1):(e=j(e),a=e.length,h=j.readOnly),this._firstFragment?(this._firstFragment=!1,o&&n&&n.params[n._isServer?"server_no_context_takeover":"client_no_context_takeover"]&&(o=a>=n._threshold),this._compress=o):(o=!1,i=0),r.fin&&(this._firstFragment=!0);let l={[L]:a,fin:r.fin,generateMask:this._generateMask,mask:r.mask,maskBuffer:this._maskBuffer,opcode:i,readOnly:h,rsv1:o};te(e)?this._state!==M?this.enqueue([this.getBlobData,e,this._compress,l,s]):this.getBlobData(e,this._compress,l,s):this._state!==M?this.enqueue([this.dispatch,e,this._compress,l,s]):this.dispatch(e,this._compress,l,s)}getBlobData(e,r,s,n){this._bufferedBytes+=s[L],this._state=ts,e.arrayBuffer().then(i=>{if(this._socket.destroyed){let a=new Error("The socket was closed while the blob was being read");process.nextTick(Ye,this,a,n);return}this._bufferedBytes-=s[L];let o=j(i);r?this.dispatch(o,r,s,n):(this._state=M,this.sendFrame(t.frame(o,s),n),this.dequeue())}).catch(i=>{process.nextTick(rs,this,i,n)})}dispatch(e,r,s,n){if(!r){this.sendFrame(t.frame(e,s),n);return}let i=this._extensions[Ct.extensionName];this._bufferedBytes+=s[L],this._state=es,i.compress(e,s.fin,(o,a)=>{if(this._socket.destroyed){let h=new Error("The socket was closed while data was being compressed");Ye(this,h,n);return}this._bufferedBytes-=s[L],this._state=M,s.readOnly=!1,this.sendFrame(t.frame(a,s),n),this.dequeue()})}dequeue(){for(;this._state===M&&this._queue.length;){let e=this._queue.shift();this._bufferedBytes-=e[3][L],Reflect.apply(e[0],this,e.slice(1))}}enqueue(e){this._bufferedBytes+=e[3][L],this._queue.push(e)}sendFrame(e,r){e.length===2?(this._socket.cork(),this._socket.write(e[0]),this._socket.write(e[1],r),this._socket.uncork()):this._socket.write(e[0],r)}};Lt.exports=Xe;function Ye(t,e,r){typeof r=="function"&&r(e);for(let s=0;s<t._queue.length;s++){let n=t._queue[s],i=n[n.length-1];typeof i=="function"&&i(e)}}function rs(t,e,r){Ye(t,e,r),t.onerror(e)}});var Wt=N((hn,Ft)=>{"use strict";var{kForOnEventAttribute:ue,kListener:Qe}=A(),Mt=Symbol("kCode"),Pt=Symbol("kData"),Bt=Symbol("kError"),Dt=Symbol("kMessage"),Ut=Symbol("kReason"),se=Symbol("kTarget"),At=Symbol("kType"),Rt=Symbol("kWasClean"),F=class{constructor(e){this[se]=null,this[At]=e}get target(){return this[se]}get type(){return this[At]}};Object.defineProperty(F.prototype,"target",{enumerable:!0});Object.defineProperty(F.prototype,"type",{enumerable:!0});var z=class extends F{constructor(e,r={}){super(e),this[Mt]=r.code===void 0?0:r.code,this[Ut]=r.reason===void 0?"":r.reason,this[Rt]=r.wasClean===void 0?!1:r.wasClean}get code(){return this[Mt]}get reason(){return this[Ut]}get wasClean(){return this[Rt]}};Object.defineProperty(z.prototype,"code",{enumerable:!0});Object.defineProperty(z.prototype,"reason",{enumerable:!0});Object.defineProperty(z.prototype,"wasClean",{enumerable:!0});var ne=class extends F{constructor(e,r={}){super(e),this[Bt]=r.error===void 0?null:r.error,this[Dt]=r.message===void 0?"":r.message}get error(){return this[Bt]}get message(){return this[Dt]}};Object.defineProperty(ne.prototype,"error",{enumerable:!0});Object.defineProperty(ne.prototype,"message",{enumerable:!0});var de=class extends F{constructor(e,r={}){super(e),this[Pt]=r.data===void 0?null:r.data}get data(){return this[Pt]}};Object.defineProperty(de.prototype,"data",{enumerable:!0});var ss={addEventListener(t,e,r={}){for(let n of this.listeners(t))if(!r[ue]&&n[Qe]===e&&!n[ue])return;let s;if(t==="message")s=function(i,o){let a=new de("message",{data:o?i:i.toString()});a[se]=this,Ce(e,this,a)};else if(t==="close")s=function(i,o){let a=new z("close",{code:i,reason:o.toString(),wasClean:this._closeFrameReceived&&this._closeFrameSent});a[se]=this,Ce(e,this,a)};else if(t==="error")s=function(i){let o=new ne("error",{error:i,message:i.message});o[se]=this,Ce(e,this,o)};else if(t==="open")s=function(){let i=new F("open");i[se]=this,Ce(e,this,i)};else return;s[ue]=!!r[ue],s[Qe]=e,r.once?this.once(t,s):this.on(t,s)},removeEventListener(t,e){for(let r of this.listeners(t))if(r[Qe]===e&&!r[ue]){this.removeListener(t,r);break}}};Ft.exports={CloseEvent:z,ErrorEvent:ne,Event:F,EventTarget:ss,MessageEvent:de};function Ce(t,e,r){typeof t=="object"&&t.handleEvent?t.handleEvent.call(t,r):t.call(e,r)}});var Je=N((cn,$t)=>{"use strict";var{tokenChars:_e}=ee();function P(t,e,r){t[e]===void 0?t[e]=[r]:t[e].push(r)}function ns(t){let e=Object.create(null),r=Object.create(null),s=!1,n=!1,i=!1,o,a,h=-1,l=-1,u=-1,c=0;for(;c<t.length;c++)if(l=t.charCodeAt(c),o===void 0)if(u===-1&&_e[l]===1)h===-1&&(h=c);else if(c!==0&&(l===32||l===9))u===-1&&h!==-1&&(u=c);else if(l===59||l===44){if(h===-1)throw new SyntaxError(`Unexpected character at index ${c}`);u===-1&&(u=c);let g=t.slice(h,u);l===44?(P(e,g,r),r=Object.create(null)):o=g,h=u=-1}else throw new SyntaxError(`Unexpected character at index ${c}`);else if(a===void 0)if(u===-1&&_e[l]===1)h===-1&&(h=c);else if(l===32||l===9)u===-1&&h!==-1&&(u=c);else if(l===59||l===44){if(h===-1)throw new SyntaxError(`Unexpected character at index ${c}`);u===-1&&(u=c),P(r,t.slice(h,u),!0),l===44&&(P(e,o,r),r=Object.create(null),o=void 0),h=u=-1}else if(l===61&&h!==-1&&u===-1)a=t.slice(h,c),h=u=-1;else throw new SyntaxError(`Unexpected character at index ${c}`);else if(n){if(_e[l]!==1)throw new SyntaxError(`Unexpected character at index ${c}`);h===-1?h=c:s||(s=!0),n=!1}else if(i)if(_e[l]===1)h===-1&&(h=c);else if(l===34&&h!==-1)i=!1,u=c;else if(l===92)n=!0;else throw new SyntaxError(`Unexpected character at index ${c}`);else if(l===34&&t.charCodeAt(c-1)===61)i=!0;else if(u===-1&&_e[l]===1)h===-1&&(h=c);else if(h!==-1&&(l===32||l===9))u===-1&&(u=c);else if(l===59||l===44){if(h===-1)throw new SyntaxError(`Unexpected character at index ${c}`);u===-1&&(u=c);let g=t.slice(h,u);s&&(g=g.replace(/\\/g,""),s=!1),P(r,a,g),l===44&&(P(e,o,r),r=Object.create(null),o=void 0),a=void 0,h=u=-1}else throw new SyntaxError(`Unexpected character at index ${c}`);if(h===-1||i||l===32||l===9)throw new SyntaxError("Unexpected end of input");u===-1&&(u=c);let _=t.slice(h,u);return o===void 0?P(e,_,r):(a===void 0?P(r,_,!0):s?P(r,a,_.replace(/\\/g,"")):P(r,a,_),P(e,o,r)),e}function is(t){return Object.keys(t).map(e=>{let r=t[e];return Array.isArray(r)||(r=[r]),r.map(s=>[e].concat(Object.keys(s).map(n=>{let i=s[n];return Array.isArray(i)||(i=[i]),i.map(o=>o===!0?n:`${n}=${o}`).join("; ")})).join("; ")).join(", ")}).join(", ")}$t.exports={format:is,parse:ns}});var Pe=N((_n,Jt)=>{"use strict";var os=require("events"),as=require("https"),ls=require("http"),jt=require("net"),fs=require("tls"),{randomBytes:hs,createHash:cs}=require("crypto"),{Duplex:un,Readable:dn}=require("stream"),{URL:et}=require("url"),q=ce(),us=Ke(),ds=Ze(),{isBlob:_s}=ee(),{BINARY_TYPES:qt,EMPTY_BUFFER:Ie,GUID:ms,kForOnEventAttribute:tt,kListener:ps,kStatusCode:gs,kWebSocket:w,NOOP:Vt}=A(),{EventTarget:{addEventListener:ys,removeEventListener:Ss}}=Wt(),{format:vs,parse:xs}=Je(),{toBuffer:bs}=fe(),Es=30*1e3,zt=Symbol("kAborted"),rt=[8,13],W=["CONNECTING","OPEN","CLOSING","CLOSED"],ws=/^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/,x=class t extends os{constructor(e,r,s){super(),this._binaryType=qt[0],this._closeCode=1006,this._closeFrameReceived=!1,this._closeFrameSent=!1,this._closeMessage=Ie,this._closeTimer=null,this._errorEmitted=!1,this._extensions={},this._paused=!1,this._protocol="",this._readyState=t.CONNECTING,this._receiver=null,this._sender=null,this._socket=null,e!==null?(this._bufferedAmount=0,this._isServer=!1,this._redirects=0,r===void 0?r=[]:Array.isArray(r)||(typeof r=="object"&&r!==null?(s=r,r=[]):r=[r]),Ht(this,e,r,s)):(this._autoPong=s.autoPong,this._isServer=!0)}get binaryType(){return this._binaryType}set binaryType(e){qt.includes(e)&&(this._binaryType=e,this._receiver&&(this._receiver._binaryType=e))}get bufferedAmount(){return this._socket?this._socket._writableState.length+this._sender._bufferedBytes:this._bufferedAmount}get extensions(){return Object.keys(this._extensions).join()}get isPaused(){return this._paused}get onclose(){return null}get onerror(){return null}get onopen(){return null}get onmessage(){return null}get protocol(){return this._protocol}get readyState(){return this._readyState}get url(){return this._url}setSocket(e,r,s){let n=new us({allowSynchronousEvents:s.allowSynchronousEvents,binaryType:this.binaryType,extensions:this._extensions,isServer:this._isServer,maxPayload:s.maxPayload,skipUTF8Validation:s.skipUTF8Validation}),i=new ds(e,this._extensions,s.generateMask);this._receiver=n,this._sender=i,this._socket=e,n[w]=this,i[w]=this,e[w]=this,n.on("conclude",Ts),n.on("drain",Ns),n.on("error",Cs),n.on("message",Is),n.on("ping",Ls),n.on("pong",Ms),i.onerror=Ps,e.setTimeout&&e.setTimeout(0),e.setNoDelay&&e.setNoDelay(),r.length>0&&e.unshift(r),e.on("close",Yt),e.on("data",Me),e.on("end",Zt),e.on("error",Qt),this._readyState=t.OPEN,this.emit("open")}emitClose(){if(!this._socket){this._readyState=t.CLOSED,this.emit("close",this._closeCode,this._closeMessage);return}this._extensions[q.extensionName]&&this._extensions[q.extensionName].cleanup(),this._receiver.removeAllListeners(),this._readyState=t.CLOSED,this.emit("close",this._closeCode,this._closeMessage)}close(e,r){if(this.readyState!==t.CLOSED){if(this.readyState===t.CONNECTING){C(this,this._req,"WebSocket was closed before the connection was established");return}if(this.readyState===t.CLOSING){this._closeFrameSent&&(this._closeFrameReceived||this._receiver._writableState.errorEmitted)&&this._socket.end();return}this._readyState=t.CLOSING,this._sender.close(e,r,!this._isServer,s=>{s||(this._closeFrameSent=!0,(this._closeFrameReceived||this._receiver._writableState.errorEmitted)&&this._socket.end())}),Xt(this)}}pause(){this.readyState===t.CONNECTING||this.readyState===t.CLOSED||(this._paused=!0,this._socket.pause())}ping(e,r,s){if(this.readyState===t.CONNECTING)throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");if(typeof e=="function"?(s=e,e=r=void 0):typeof r=="function"&&(s=r,r=void 0),typeof e=="number"&&(e=e.toString()),this.readyState!==t.OPEN){st(this,e,s);return}r===void 0&&(r=!this._isServer),this._sender.ping(e||Ie,r,s)}pong(e,r,s){if(this.readyState===t.CONNECTING)throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");if(typeof e=="function"?(s=e,e=r=void 0):typeof r=="function"&&(s=r,r=void 0),typeof e=="number"&&(e=e.toString()),this.readyState!==t.OPEN){st(this,e,s);return}r===void 0&&(r=!this._isServer),this._sender.pong(e||Ie,r,s)}resume(){this.readyState===t.CONNECTING||this.readyState===t.CLOSED||(this._paused=!1,this._receiver._writableState.needDrain||this._socket.resume())}send(e,r,s){if(this.readyState===t.CONNECTING)throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");if(typeof r=="function"&&(s=r,r={}),typeof e=="number"&&(e=e.toString()),this.readyState!==t.OPEN){st(this,e,s);return}let n={binary:typeof e!="string",mask:!this._isServer,compress:!0,fin:!0,...r};this._extensions[q.extensionName]||(n.compress=!1),this._sender.send(e||Ie,n,s)}terminate(){if(this.readyState!==t.CLOSED){if(this.readyState===t.CONNECTING){C(this,this._req,"WebSocket was closed before the connection was established");return}this._socket&&(this._readyState=t.CLOSING,this._socket.destroy())}}};Object.defineProperty(x,"CONNECTING",{enumerable:!0,value:W.indexOf("CONNECTING")});Object.defineProperty(x.prototype,"CONNECTING",{enumerable:!0,value:W.indexOf("CONNECTING")});Object.defineProperty(x,"OPEN",{enumerable:!0,value:W.indexOf("OPEN")});Object.defineProperty(x.prototype,"OPEN",{enumerable:!0,value:W.indexOf("OPEN")});Object.defineProperty(x,"CLOSING",{enumerable:!0,value:W.indexOf("CLOSING")});Object.defineProperty(x.prototype,"CLOSING",{enumerable:!0,value:W.indexOf("CLOSING")});Object.defineProperty(x,"CLOSED",{enumerable:!0,value:W.indexOf("CLOSED")});Object.defineProperty(x.prototype,"CLOSED",{enumerable:!0,value:W.indexOf("CLOSED")});["binaryType","bufferedAmount","extensions","isPaused","protocol","readyState","url"].forEach(t=>{Object.defineProperty(x.prototype,t,{enumerable:!0})});["open","error","close","message"].forEach(t=>{Object.defineProperty(x.prototype,`on${t}`,{enumerable:!0,get(){for(let e of this.listeners(t))if(e[tt])return e[ps];return null},set(e){for(let r of this.listeners(t))if(r[tt]){this.removeListener(t,r);break}typeof e=="function"&&this.addEventListener(t,e,{[tt]:!0})}})});x.prototype.addEventListener=ys;x.prototype.removeEventListener=Ss;Jt.exports=x;function Ht(t,e,r,s){let n={allowSynchronousEvents:!0,autoPong:!0,protocolVersion:rt[1],maxPayload:104857600,skipUTF8Validation:!1,perMessageDeflate:!0,followRedirects:!1,maxRedirects:10,...s,socketPath:void 0,hostname:void 0,protocol:void 0,timeout:void 0,method:"GET",host:void 0,path:void 0,port:void 0};if(t._autoPong=n.autoPong,!rt.includes(n.protocolVersion))throw new RangeError(`Unsupported protocol version: ${n.protocolVersion} (supported versions: ${rt.join(", ")})`);let i;if(e instanceof et)i=e;else try{i=new et(e)}catch{throw new SyntaxError(`Invalid URL: ${e}`)}i.protocol==="http:"?i.protocol="ws:":i.protocol==="https:"&&(i.protocol="wss:"),t._url=i.href;let o=i.protocol==="wss:",a=i.protocol==="ws+unix:",h;if(i.protocol!=="ws:"&&!o&&!a?h=`The URL's protocol must be one of "ws:", "wss:", "http:", "https:", or "ws+unix:"`:a&&!i.pathname?h="The URL's pathname is empty":i.hash&&(h="The URL contains a fragment identifier"),h){let d=new SyntaxError(h);if(t._redirects===0)throw d;Le(t,d);return}let l=o?443:80,u=hs(16).toString("base64"),c=o?as.request:ls.request,_=new Set,g;if(n.createConnection=n.createConnection||(o?Os:ks),n.defaultPort=n.defaultPort||l,n.port=i.port||l,n.host=i.hostname.startsWith("[")?i.hostname.slice(1,-1):i.hostname,n.headers={...n.headers,"Sec-WebSocket-Version":n.protocolVersion,"Sec-WebSocket-Key":u,Connection:"Upgrade",Upgrade:"websocket"},n.path=i.pathname+i.search,n.timeout=n.handshakeTimeout,n.perMessageDeflate&&(g=new q(n.perMessageDeflate!==!0?n.perMessageDeflate:{},!1,n.maxPayload),n.headers["Sec-WebSocket-Extensions"]=vs({[q.extensionName]:g.offer()})),r.length){for(let d of r){if(typeof d!="string"||!ws.test(d)||_.has(d))throw new SyntaxError("An invalid or duplicated subprotocol was specified");_.add(d)}n.headers["Sec-WebSocket-Protocol"]=r.join(",")}if(n.origin&&(n.protocolVersion<13?n.headers["Sec-WebSocket-Origin"]=n.origin:n.headers.Origin=n.origin),(i.username||i.password)&&(n.auth=`${i.username}:${i.password}`),a){let d=n.path.split(":");n.socketPath=d[0],n.path=d[1]}let v;if(n.followRedirects){if(t._redirects===0){t._originalIpc=a,t._originalSecure=o,t._originalHostOrSocketPath=a?n.socketPath:i.host;let d=s&&s.headers;if(s={...s,headers:{}},d)for(let[f,y]of Object.entries(d))s.headers[f.toLowerCase()]=y}else if(t.listenerCount("redirect")===0){let d=a?t._originalIpc?n.socketPath===t._originalHostOrSocketPath:!1:t._originalIpc?!1:i.host===t._originalHostOrSocketPath;(!d||t._originalSecure&&!o)&&(delete n.headers.authorization,delete n.headers.cookie,d||delete n.headers.host,n.auth=void 0)}n.auth&&!s.headers.authorization&&(s.headers.authorization="Basic "+Buffer.from(n.auth).toString("base64")),v=t._req=c(n),t._redirects&&t.emit("redirect",t.url,v)}else v=t._req=c(n);n.timeout&&v.on("timeout",()=>{C(t,v,"Opening handshake has timed out")}),v.on("error",d=>{v===null||v[zt]||(v=t._req=null,Le(t,d))}),v.on("response",d=>{let f=d.headers.location,y=d.statusCode;if(f&&n.followRedirects&&y>=300&&y<400){if(++t._redirects>n.maxRedirects){C(t,v,"Maximum redirects exceeded");return}v.abort();let T;try{T=new et(f,e)}catch{let b=new SyntaxError(`Invalid URL: ${f}`);Le(t,b);return}Ht(t,T,r,s)}else t.emit("unexpected-response",v,d)||C(t,v,`Unexpected server response: ${d.statusCode}`)}),v.on("upgrade",(d,f,y)=>{if(t.emit("upgrade",d),t.readyState!==x.CONNECTING)return;v=t._req=null;let T=d.headers.upgrade;if(T===void 0||T.toLowerCase()!=="websocket"){C(t,f,"Invalid Upgrade header");return}let S=cs("sha1").update(u+ms).digest("base64");if(d.headers["sec-websocket-accept"]!==S){C(t,f,"Invalid Sec-WebSocket-Accept header");return}let b=d.headers["sec-websocket-protocol"],B;if(b!==void 0?_.size?_.has(b)||(B="Server sent an invalid subprotocol"):B="Server sent a subprotocol but none was requested":_.size&&(B="Server sent no subprotocol"),B){C(t,f,B);return}b&&(t._protocol=b);let Se=d.headers["sec-websocket-extensions"];if(Se!==void 0){if(!g){C(t,f,"Server sent a Sec-WebSocket-Extensions header but no extension was requested");return}let X;try{X=xs(Se)}catch{C(t,f,"Invalid Sec-WebSocket-Extensions header");return}let ie=Object.keys(X);if(ie.length!==1||ie[0]!==q.extensionName){C(t,f,"Server indicated an extension that was not requested");return}try{g.accept(X[q.extensionName])}catch{C(t,f,"Invalid Sec-WebSocket-Extensions header");return}t._extensions[q.extensionName]=g}t.setSocket(f,y,{allowSynchronousEvents:n.allowSynchronousEvents,generateMask:n.generateMask,maxPayload:n.maxPayload,skipUTF8Validation:n.skipUTF8Validation})}),n.finishRequest?n.finishRequest(v,t):v.end()}function Le(t,e){t._readyState=x.CLOSING,t._errorEmitted=!0,t.emit("error",e),t.emitClose()}function ks(t){return t.path=t.socketPath,jt.connect(t)}function Os(t){return t.path=void 0,!t.servername&&t.servername!==""&&(t.servername=jt.isIP(t.host)?"":t.host),fs.connect(t)}function C(t,e,r){t._readyState=x.CLOSING;let s=new Error(r);Error.captureStackTrace(s,C),e.setHeader?(e[zt]=!0,e.abort(),e.socket&&!e.socket.destroyed&&e.socket.destroy(),process.nextTick(Le,t,s)):(e.destroy(s),e.once("error",t.emit.bind(t,"error")),e.once("close",t.emitClose.bind(t)))}function st(t,e,r){if(e){let s=_s(e)?e.size:bs(e).length;t._socket?t._sender._bufferedBytes+=s:t._bufferedAmount+=s}if(r){let s=new Error(`WebSocket is not open: readyState ${t.readyState} (${W[t.readyState]})`);process.nextTick(r,s)}}function Ts(t,e){let r=this[w];r._closeFrameReceived=!0,r._closeMessage=e,r._closeCode=t,r._socket[w]!==void 0&&(r._socket.removeListener("data",Me),process.nextTick(Kt,r._socket),t===1005?r.close():r.close(t,e))}function Ns(){let t=this[w];t.isPaused||t._socket.resume()}function Cs(t){let e=this[w];e._socket[w]!==void 0&&(e._socket.removeListener("data",Me),process.nextTick(Kt,e._socket),e.close(t[gs])),e._errorEmitted||(e._errorEmitted=!0,e.emit("error",t))}function Gt(){this[w].emitClose()}function Is(t,e){this[w].emit("message",t,e)}function Ls(t){let e=this[w];e._autoPong&&e.pong(t,!this._isServer,Vt),e.emit("ping",t)}function Ms(t){this[w].emit("pong",t)}function Kt(t){t.resume()}function Ps(t){let e=this[w];e.readyState!==x.CLOSED&&(e.readyState===x.OPEN&&(e._readyState=x.CLOSING,Xt(e)),this._socket.end(),e._errorEmitted||(e._errorEmitted=!0,e.emit("error",t)))}function Xt(t){t._closeTimer=setTimeout(t._socket.destroy.bind(t._socket),Es)}function Yt(){let t=this[w];this.removeListener("close",Yt),this.removeListener("data",Me),this.removeListener("end",Zt),t._readyState=x.CLOSING;let e;!this._readableState.endEmitted&&!t._closeFrameReceived&&!t._receiver._writableState.errorEmitted&&(e=t._socket.read())!==null&&t._receiver.write(e),t._receiver.end(),this[w]=void 0,clearTimeout(t._closeTimer),t._receiver._writableState.finished||t._receiver._writableState.errorEmitted?t.emitClose():(t._receiver.on("error",Gt),t._receiver.on("finish",Gt))}function Me(t){this[w]._receiver.write(t)||this.pause()}function Zt(){let t=this[w];t._readyState=x.CLOSING,t._receiver.end(),this.end()}function Qt(){let t=this[w];this.removeListener("error",Qt),this.on("error",Vt),t&&(t._readyState=x.CLOSING,this.destroy())}});var sr=N((pn,rr)=>{"use strict";var mn=Pe(),{Duplex:Bs}=require("stream");function er(t){t.emit("close")}function Ds(){!this.destroyed&&this._writableState.finished&&this.destroy()}function tr(t){this.removeListener("error",tr),this.destroy(),this.listenerCount("error")===0&&this.emit("error",t)}function Us(t,e){let r=!0,s=new Bs({...e,autoDestroy:!1,emitClose:!1,objectMode:!1,writableObjectMode:!1});return t.on("message",function(i,o){let a=!o&&s._readableState.objectMode?i.toString():i;s.push(a)||t.pause()}),t.once("error",function(i){s.destroyed||(r=!1,s.destroy(i))}),t.once("close",function(){s.destroyed||s.push(null)}),s._destroy=function(n,i){if(t.readyState===t.CLOSED){i(n),process.nextTick(er,s);return}let o=!1;t.once("error",function(h){o=!0,i(h)}),t.once("close",function(){o||i(n),process.nextTick(er,s)}),r&&t.terminate()},s._final=function(n){if(t.readyState===t.CONNECTING){t.once("open",function(){s._final(n)});return}t._socket!==null&&(t._socket._writableState.finished?(n(),s._readableState.endEmitted&&s.destroy()):(t._socket.once("finish",function(){n()}),t.close()))},s._read=function(){t.isPaused&&t.resume()},s._write=function(n,i,o){if(t.readyState===t.CONNECTING){t.once("open",function(){s._write(n,i,o)});return}t.send(n,o)},s.on("end",Ds),s.on("error",tr),s}rr.exports=Us});var ir=N((gn,nr)=>{"use strict";var{tokenChars:As}=ee();function Rs(t){let e=new Set,r=-1,s=-1,n=0;for(n;n<t.length;n++){let o=t.charCodeAt(n);if(s===-1&&As[o]===1)r===-1&&(r=n);else if(n!==0&&(o===32||o===9))s===-1&&r!==-1&&(s=n);else if(o===44){if(r===-1)throw new SyntaxError(`Unexpected character at index ${n}`);s===-1&&(s=n);let a=t.slice(r,s);if(e.has(a))throw new SyntaxError(`The "${a}" subprotocol is duplicated`);e.add(a),r=s=-1}else throw new SyntaxError(`Unexpected character at index ${n}`)}if(r===-1||s!==-1)throw new SyntaxError("Unexpected end of input");let i=t.slice(r,n);if(e.has(i))throw new SyntaxError(`The "${i}" subprotocol is duplicated`);return e.add(i),e}nr.exports={parse:Rs}});var ur=N((Sn,cr)=>{"use strict";var Fs=require("events"),Be=require("http"),{Duplex:yn}=require("stream"),{createHash:Ws}=require("crypto"),or=Je(),H=ce(),$s=ir(),qs=Pe(),{GUID:Gs,kWebSocket:js}=A(),Vs=/^[+/0-9A-Za-z]{22}==$/,ar=0,lr=1,hr=2,nt=class extends Fs{constructor(e,r){if(super(),e={allowSynchronousEvents:!0,autoPong:!0,maxPayload:100*1024*1024,skipUTF8Validation:!1,perMessageDeflate:!1,handleProtocols:null,clientTracking:!0,verifyClient:null,noServer:!1,backlog:null,server:null,host:null,path:null,port:null,WebSocket:qs,...e},e.port==null&&!e.server&&!e.noServer||e.port!=null&&(e.server||e.noServer)||e.server&&e.noServer)throw new TypeError('One and only one of the "port", "server", or "noServer" options must be specified');if(e.port!=null?(this._server=Be.createServer((s,n)=>{let i=Be.STATUS_CODES[426];n.writeHead(426,{"Content-Length":i.length,"Content-Type":"text/plain"}),n.end(i)}),this._server.listen(e.port,e.host,e.backlog,r)):e.server&&(this._server=e.server),this._server){let s=this.emit.bind(this,"connection");this._removeListeners=zs(this._server,{listening:this.emit.bind(this,"listening"),error:this.emit.bind(this,"error"),upgrade:(n,i,o)=>{this.handleUpgrade(n,i,o,s)}})}e.perMessageDeflate===!0&&(e.perMessageDeflate={}),e.clientTracking&&(this.clients=new Set,this._shouldEmitClose=!1),this.options=e,this._state=ar}address(){if(this.options.noServer)throw new Error('The server is operating in "noServer" mode');return this._server?this._server.address():null}close(e){if(this._state===hr){e&&this.once("close",()=>{e(new Error("The server is not running"))}),process.nextTick(me,this);return}if(e&&this.once("close",e),this._state!==lr)if(this._state=lr,this.options.noServer||this.options.server)this._server&&(this._removeListeners(),this._removeListeners=this._server=null),this.clients?this.clients.size?this._shouldEmitClose=!0:process.nextTick(me,this):process.nextTick(me,this);else{let r=this._server;this._removeListeners(),this._removeListeners=this._server=null,r.close(()=>{me(this)})}}shouldHandle(e){if(this.options.path){let r=e.url.indexOf("?");if((r!==-1?e.url.slice(0,r):e.url)!==this.options.path)return!1}return!0}handleUpgrade(e,r,s,n){r.on("error",fr);let i=e.headers["sec-websocket-key"],o=e.headers.upgrade,a=+e.headers["sec-websocket-version"];if(e.method!=="GET"){K(this,e,r,405,"Invalid HTTP method");return}if(o===void 0||o.toLowerCase()!=="websocket"){K(this,e,r,400,"Invalid Upgrade header");return}if(i===void 0||!Vs.test(i)){K(this,e,r,400,"Missing or invalid Sec-WebSocket-Key header");return}if(a!==13&&a!==8){K(this,e,r,400,"Missing or invalid Sec-WebSocket-Version header",{"Sec-WebSocket-Version":"13, 8"});return}if(!this.shouldHandle(e)){pe(r,400);return}let h=e.headers["sec-websocket-protocol"],l=new Set;if(h!==void 0)try{l=$s.parse(h)}catch{K(this,e,r,400,"Invalid Sec-WebSocket-Protocol header");return}let u=e.headers["sec-websocket-extensions"],c={};if(this.options.perMessageDeflate&&u!==void 0){let _=new H(this.options.perMessageDeflate,!0,this.options.maxPayload);try{let g=or.parse(u);g[H.extensionName]&&(_.accept(g[H.extensionName]),c[H.extensionName]=_)}catch{K(this,e,r,400,"Invalid or unacceptable Sec-WebSocket-Extensions header");return}}if(this.options.verifyClient){let _={origin:e.headers[`${a===8?"sec-websocket-origin":"origin"}`],secure:!!(e.socket.authorized||e.socket.encrypted),req:e};if(this.options.verifyClient.length===2){this.options.verifyClient(_,(g,v,d,f)=>{if(!g)return pe(r,v||401,d,f);this.completeUpgrade(c,i,l,e,r,s,n)});return}if(!this.options.verifyClient(_))return pe(r,401)}this.completeUpgrade(c,i,l,e,r,s,n)}completeUpgrade(e,r,s,n,i,o,a){if(!i.readable||!i.writable)return i.destroy();if(i[js])throw new Error("server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration");if(this._state>ar)return pe(i,503);let l=["HTTP/1.1 101 Switching Protocols","Upgrade: websocket","Connection: Upgrade",`Sec-WebSocket-Accept: ${Ws("sha1").update(r+Gs).digest("base64")}`],u=new this.options.WebSocket(null,void 0,this.options);if(s.size){let c=this.options.handleProtocols?this.options.handleProtocols(s,n):s.values().next().value;c&&(l.push(`Sec-WebSocket-Protocol: ${c}`),u._protocol=c)}if(e[H.extensionName]){let c=e[H.extensionName].params,_=or.format({[H.extensionName]:[c]});l.push(`Sec-WebSocket-Extensions: ${_}`),u._extensions=e}this.emit("headers",l,n),i.write(l.concat(`\r
2
+ `).join(`\r
3
+ `)),i.removeListener("error",fr),u.setSocket(i,o,{allowSynchronousEvents:this.options.allowSynchronousEvents,maxPayload:this.options.maxPayload,skipUTF8Validation:this.options.skipUTF8Validation}),this.clients&&(this.clients.add(u),u.on("close",()=>{this.clients.delete(u),this._shouldEmitClose&&!this.clients.size&&process.nextTick(me,this)})),a(u,n)}};cr.exports=nt;function zs(t,e){for(let r of Object.keys(e))t.on(r,e[r]);return function(){for(let s of Object.keys(e))t.removeListener(s,e[s])}}function me(t){t._state=hr,t.emit("close")}function fr(){this.destroy()}function pe(t,e,r,s){r=r||Be.STATUS_CODES[e],s={Connection:"close","Content-Type":"text/html","Content-Length":Buffer.byteLength(r),...s},t.once("finish",t.destroy),t.end(`HTTP/1.1 ${e} ${Be.STATUS_CODES[e]}\r
4
+ `+Object.keys(s).map(n=>`${n}: ${s[n]}`).join(`\r
5
+ `)+`\r
6
+ \r
7
+ `+r)}function K(t,e,r,s,n,i){if(t.listenerCount("wsClientError")){let o=new Error(n);Error.captureStackTrace(o,K),t.emit("wsClientError",o,r,e)}else pe(r,s,n,i)}});var Js={};Tr(Js,{MessageStoreKDB:()=>ot});module.exports=Nr(Js);var ye=require("fixparser-common");var Hs=le(sr(),1),Ks=le(Ke(),1),Xs=le(Ze(),1),ge=le(Pe(),1),Ys=le(ur(),1);function De(t){for(var e=[],r=0;r<t.length;r++){var s=t.charCodeAt(r);s<128?e.push(s):s<2048?e.push(192|s>>6,128|s&63):s<55296||s>=57344?e.push(224|s>>12,128|s>>6&63,128|s&63):(s=65536+((s&1023)<<10|t.charCodeAt(++r)&1023),e.push(240|s>>18,128|s>>12&63,128|s>>6&63,128|s&63))}return e}function dr(t){for(var e="",r,s,n,i=0;i<t.length;i++)switch((r=t[i])>>4){case 0:case 1:case 2:case 3:case 4:case 5:case 6:case 7:e+=String.fromCharCode(r);break;case 12:case 13:s=t[++i],e+=String.fromCharCode((r&31)<<6|s&63);break;case 14:s=t[++i],n=t[++i],e+=String.fromCharCode((r&15)<<12|(s&63)<<6|(n&63)<<0);break}return e}function Zs(t){if(t=new Uint8Array(t),t.length<13)return t;function e(_){return new Uint32Array(_)[0]}for(var r=0,s=0,n=0,i=8,o=i,a=0,h=12,l=e(t.buffer.slice(8,12)),u=new Uint8Array(l),c=new Int32Array(256);i<u.length;){if(a==0&&(n=255&t[h++],a=1),(n&a)!=0)for(s=c[255&t[h++]],u[i++]=u[s++],u[i++]=u[s++],r=255&t[h++],m=0;m<r;m++)u[i+m]=u[s+m];else u[i++]=t[h++];for(;o<i-1;)c[255&u[o]^255&u[o+1]]=o++;(n&a)!=0&&(i+=r,o=i),a*=2,a==256&&(a=0)}return u}function Qs(t){return new Uint8Array(t)[2]==1}function Ue(t){var e=t[0],r=8,s=Math.pow(2,32),n=new Uint8Array(t),i=new Int8Array(t),o=new Uint8Array(8),a=new Int16Array(o.buffer),h=new Int32Array(o.buffer),l=new Float32Array(o.buffer),u=new Float64Array(o.buffer);let c=864e5,_=c*10957;function g(){return d()==1}function v(){return String.fromCharCode(d())}function d(){return i[r++]}function f(E){for(var p=0;p<E;p++)o[p]=n[r++]}function y(){return n[r++]}function T(){for(var E="0123456789abcdef",p="",k=0;k<16;k++){var O=y();p+=k==4||k==6||k==8||k==10?"-":"",p+=E[O>>4],p+=E[O&15]}return p}function S(){f(2);var E=a[0];return E==-32768?NaN:E==-32767?-1/0:E==32767?1/0:E}function b(){f(4);var E=h[0];return E==-2147483648?NaN:E==-2147483647?-1/0:E==2147483647?1/0:E}function B(){f(8);var E=h[1],p=h[0];return E*s+(p>=0?p:s+p)}function Se(){return f(4),l[0]}function X(){return f(8),u[0]}function ie(){for(var E=r,p,k=[];(p=y())!==0;)k.push(p);return dr(k)}function oe(){return G(B()/1e6)}function Ae(){return new Date(Date.UTC(2e3,b(),1))}function G(E){return new Date(_+E)}function _r(){return G(b()*c)}function mr(){return G(X()*c)}function pr(){return G(B()/1e6)}function gr(){return G(b()*1e3)}function yr(){return G(b()*6e4)}function Sr(){return G(b())}function D(){var E=[D,g,T,null,y,S,b,B,Se,X,v,ie,oe,Ae,_r,mr,pr,yr,gr,Sr],p=0,k,O=d();if(O<0&&O>-20)return E[-O]();if(O>99){if(O==100)return ie(),D();if(O<104)return d()===0&&O==101?null:"func";if(O>105)D();else for(k=b();p<k;p++)D();return"func"}if(O==99){var vr=n[r]==98,Y=D(),Z=D(),U;if(vr)U=new Array(2),U[0]=Y,U[1]=Z;else{U={};for(var p=0;p<Y.length;p++)U[Y[p]]=Z[p]}return U}if(r++,O==98){d();for(var Y=D(),Z=D(),ae=new Array(Z[0].length),ve=0;ve<Z[0].length;ve++){for(var U={},p=0;p<Y.length;p++)U[Y[p]]=Z[p][ve];ae[ve]=U}return ae}if(k=b(),O==10){var at=[];for(k+=r;r<k;at.push(y()));return dr(at)}var ae=new Array(k),xr=E[O];for(p=0;p<k;p++)ae[p]=xr();return ae}return Qs(t)?Ue(Zs(n)):D()}function it(t){var e=1,r=0,s,n=new Uint8Array(8),i=new Int32Array(n.buffer),o=new Float64Array(n.buffer);function a(f){var y=typeof f;return y!=="object"&&y!=="function"?y:f?f instanceof Array?"array":f instanceof Date?"date":"object":"null"}function h(f){return Object.keys(f)}function l(f){var y=[];for(var T in f)y.push(f[T]);return y}function u(f,y){var T=y||a(f);switch(T){case"null":return 2;case"object":return 1+u(h(f),"symbols")+u(l(f),null);case"boolean":return 2;case"number":return 9;case"array":{for(var S=6,b=0;b<f.length;b++)S+=u(f[b],null);return S}case"symbols":{for(var S=6,b=0;b<f.length;b++)S+=u(f[b],"symbol");return S}case"string":return De(f).length+(f[0]=="`"?1:6);case"date":return 9;case"symbol":return 2+De(f).length}throw"bad type "+T}function c(f){s[r++]=f}function _(f){for(var y=0;y<f;y++)s[r++]=n[y]}function g(f,y){var T=y||a(f);switch(T){case"null":c(101),c(0);break;case"boolean":c(-1),c(f?1:0);break;case"number":c(-9),o[0]=f,_(8);break;case"date":c(-15),o[0]=(f.getTime()-new Date(f).getTimezoneOffset()*6e4)/864e5-10957,_(8);break;case"symbol":{c(-11),f=De(f);for(var S=0;S<f.length;S++)c(f[S]);c(0)}break;case"string":if(f[0]=="`")g(f.substr(1),"symbol");else{c(10),c(0),f=De(f),i[0]=f.length,_(4);for(var S=0;S<f.length;S++)c(f[S])}break;case"object":c(99),g(h(f),"symbols"),g(l(f),null);break;case"array":{c(0),c(0),i[0]=f.length,_(4);for(var S=0;S<f.length;S++)g(f[S],null)}break;case"symbols":{c(0),c(0),i[0]=f.length,_(4);for(var S=0;S<f.length;S++)g(f[S],"symbol")}break}}var v=u(t,null),d=new ArrayBuffer(8+v);return s=new Uint8Array(d),c(1),c(0),c(0),c(0),i[0]=s.length,_(4),g(t,null),d}var ot=class{nextMsgSeqNum=1;inMemoryMessageStore=new ye.MessageBuffer(1048576);host;port;tableName="FIXParser";ws;parser;logger;writeInterval=5e3;writeIntervalId;maxBufferSize;constructor({host:e,port:r,tableName:s,parser:n,logger:i,onReady:o,maxBufferSize:a=2500,writeInterval:h=5e3}){this.host=e,this.port=r,this.maxBufferSize=a,this.writeInterval=h,this.parser=n,s&&(this.tableName=s),i&&(this.logger=i),this.logger?.log({level:"info",message:`FIXParser (MessageStoreKDB): -- Connecting to ws://${this.host}:${this.port}...`}),this.ws=new ge.default(`ws://${this.host}:${this.port}`),this.ws.binaryType="arraybuffer",this.ws.onopen=async()=>{this.logger?.log({level:"info",message:`FIXParser (MessageStoreKDB): -- Successfully opened connection to ws://${this.host}:${this.port}...`}),(await this.sendAsync("tables[]"))?.includes(this.tableName)?(this.logger?.log({level:"info",message:`FIXParser (MessageStoreKDB): -- ${this.tableName} table found.`}),o()):(this.logger?.log({level:"info",message:"FIXParser (MessageStoreKDB): -- Setting up FIXParser table..."}),this.send(`meta ${this.tableName}:([] msgSequence:\`int$(); message:())`),this.send(`\`msgSequence xkey \`${this.tableName}`),o())},this.ws.onclose=()=>{this.logger?.log({level:"info",message:"FIXParser (MessageStoreKDB): -- Closed"}),this.stopWriteInterval()},this.ws.onerror=l=>{this.logger?.log({level:"error",message:"FIXParser (MessageStoreKDB): -- Error:",error:l}),this.stopWriteInterval()},this.writeIntervalId=setInterval(()=>this.writeToKDB(),this.writeInterval)}send(e){let r=(0,ye.uuidv4)().replace(/-/g,""),s=`enlist \`${r}, ${e}`;this.ws.readyState!==ge.default.OPEN&&this.logger?.log({level:"warn",message:`FIXParser (MessageStoreKDB): -- WebSocket not ready! Ignoring command ${e}...`}),this.ws.onmessage=n=>{try{let i=Ue(n.data)}catch(i){this.logger?.log({level:"warn",message:`FIXParser (MessageStoreKDB): -- Error parsing response to message id ${r}: ${i}`})}},this.ws.send(it(s))}sendAsync(e){let r=(0,ye.uuidv4)().replace(/-/g,""),s=`enlist \`${r}, ${e}`;return this.ws.readyState!==ge.default.OPEN?(this.logger?.log({level:"warn",message:`FIXParser (MessageStoreKDB): -- WebSocket not ready! Ignoring command ${e}...`}),Promise.resolve(void 0)):new Promise((n,i)=>{this.ws.onmessage=o=>{try{let a=Ue(o.data),h=a[0][0],l=a[0].slice(1);h===r&&n(l)}catch(a){this.logger?.log({level:"warn",message:`FIXParser (MessageStoreKDB): -- Error parsing response to message id ${r}: ${a}`}),i(new Error(`Error parsing response to message id ${r}`))}},this.ws.send(it(s))})}async writeToKDB(){let e=this.inMemoryMessageStore.getAll(),r=[];if(e.length>0){for(let s of e){r.push(s.messageSequence);let n=s.encode("|"),i=await this.sendAsync(`\`${this.tableName} upsert (${s.messageSequence}i;"${n}")`)}for(let s of r)this.inMemoryMessageStore.remove(s)}}add(e){this.inMemoryMessageStore.add(e),this.size()>=this.maxBufferSize&&this.writeToKDB()}getByMsgSequence(){throw new Error("Not implemented, please use getByMsgSequenceAsync()")}async getByMsgSequenceAsync(e){let r=`select message from ${this.tableName} where msgSequence=${e}i`,s=await this.sendAsync(r);if(s?.length>0)return this.parser.parse(s[0].message)[0]}update(e,r){let s=`${this.tableName}:${this.tableName} upsert (${e}i; "${r.encode("|")}")`;return this.send(s),!0}remove(e){this.inMemoryMessageStore.remove(e);let r=`delete from ${this.tableName} where msgSequence=${e}`;this.send(r)}exists(e){return!!this.inMemoryMessageStore.exists(e)}getAll(){return this.inMemoryMessageStore.getAll()}async getAllAsync(){let e=this.inMemoryMessageStore.getAll();if(e.length>0)return e;let r=`select from ${this.tableName}`,s=await this.sendAsync(r),n=[];for(let i of s){let o=this.parser.parse(i.message)[0];n.push(o)}return Promise.resolve(n)}size(){return this.inMemoryMessageStore.size()}resize(e){this.maxBufferSize=e}clear(){this.inMemoryMessageStore.clear(),this.send(`delete from ${this.tableName}`)}getCapacity(){return this.maxBufferSize}stopWriteInterval(){clearInterval(this.writeIntervalId)}setNextMsgSeqNum(e){if(e<=0)throw new Error("Message sequence number must be positive.");return this.nextMsgSeqNum=e,this.nextMsgSeqNum}getNextMsgSeqNum(){return this.nextMsgSeqNum}};0&&(module.exports={MessageStoreKDB});
4302
8
  //# sourceMappingURL=MessageStoreKDB.js.map