libav-wasm 0.8.2 → 0.8.4

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.
package/build/index.js CHANGED
@@ -1,851 +1,677 @@
1
+ //#region \0/home/banou/dev/libav-wasm/node_modules/eventemitter3/index.js?commonjs-module
1
2
  var eventemitter3Exports = {};
2
- var eventemitter3 = {
3
- get exports(){ return eventemitter3Exports; },
4
- set exports(v){ eventemitter3Exports = v; },
5
- };
6
-
7
- (function (module) {
8
-
9
- var has = Object.prototype.hasOwnProperty
10
- , prefix = '~';
11
-
3
+ //#endregion
4
+ //#region node_modules/eventemitter3/index.js
5
+ (function(module) {
6
+ "use strict";
7
+ var has = Object.prototype.hasOwnProperty, prefix = "~";
12
8
  /**
13
- * Constructor to create a storage for our `EE` objects.
14
- * An `Events` instance is a plain object whose properties are event names.
15
- *
16
- * @constructor
17
- * @private
18
- */
9
+ * Constructor to create a storage for our `EE` objects.
10
+ * An `Events` instance is a plain object whose properties are event names.
11
+ *
12
+ * @constructor
13
+ * @private
14
+ */
19
15
  function Events() {}
20
-
21
- //
22
- // We try to not inherit from `Object.prototype`. In some engines creating an
23
- // instance in this way is faster than calling `Object.create(null)` directly.
24
- // If `Object.create(null)` is not supported we prefix the event names with a
25
- // character to make sure that the built-in object properties are not
26
- // overridden or used as an attack vector.
27
- //
28
16
  if (Object.create) {
29
- Events.prototype = Object.create(null);
30
-
31
- //
32
- // This hack is needed because the `__proto__` property is still inherited in
33
- // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
34
- //
35
- if (!new Events().__proto__) prefix = false;
17
+ Events.prototype = Object.create(null);
18
+ if (!new Events().__proto__) prefix = false;
36
19
  }
37
-
38
20
  /**
39
- * Representation of a single event listener.
40
- *
41
- * @param {Function} fn The listener function.
42
- * @param {*} context The context to invoke the listener with.
43
- * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
44
- * @constructor
45
- * @private
46
- */
21
+ * Representation of a single event listener.
22
+ *
23
+ * @param {Function} fn The listener function.
24
+ * @param {*} context The context to invoke the listener with.
25
+ * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
26
+ * @constructor
27
+ * @private
28
+ */
47
29
  function EE(fn, context, once) {
48
- this.fn = fn;
49
- this.context = context;
50
- this.once = once || false;
30
+ this.fn = fn;
31
+ this.context = context;
32
+ this.once = once || false;
51
33
  }
52
-
53
34
  /**
54
- * Add a listener for a given event.
55
- *
56
- * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
57
- * @param {(String|Symbol)} event The event name.
58
- * @param {Function} fn The listener function.
59
- * @param {*} context The context to invoke the listener with.
60
- * @param {Boolean} once Specify if the listener is a one-time listener.
61
- * @returns {EventEmitter}
62
- * @private
63
- */
35
+ * Add a listener for a given event.
36
+ *
37
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
38
+ * @param {(String|Symbol)} event The event name.
39
+ * @param {Function} fn The listener function.
40
+ * @param {*} context The context to invoke the listener with.
41
+ * @param {Boolean} once Specify if the listener is a one-time listener.
42
+ * @returns {EventEmitter}
43
+ * @private
44
+ */
64
45
  function addListener(emitter, event, fn, context, once) {
65
- if (typeof fn !== 'function') {
66
- throw new TypeError('The listener must be a function');
67
- }
68
-
69
- var listener = new EE(fn, context || emitter, once)
70
- , evt = prefix ? prefix + event : event;
71
-
72
- if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
73
- else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
74
- else emitter._events[evt] = [emitter._events[evt], listener];
75
-
76
- return emitter;
46
+ if (typeof fn !== "function") throw new TypeError("The listener must be a function");
47
+ var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
48
+ if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
49
+ else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
50
+ else emitter._events[evt] = [emitter._events[evt], listener];
51
+ return emitter;
77
52
  }
78
-
79
53
  /**
80
- * Clear event by name.
81
- *
82
- * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
83
- * @param {(String|Symbol)} evt The Event name.
84
- * @private
85
- */
54
+ * Clear event by name.
55
+ *
56
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
57
+ * @param {(String|Symbol)} evt The Event name.
58
+ * @private
59
+ */
86
60
  function clearEvent(emitter, evt) {
87
- if (--emitter._eventsCount === 0) emitter._events = new Events();
88
- else delete emitter._events[evt];
61
+ if (--emitter._eventsCount === 0) emitter._events = new Events();
62
+ else delete emitter._events[evt];
89
63
  }
90
-
91
64
  /**
92
- * Minimal `EventEmitter` interface that is molded against the Node.js
93
- * `EventEmitter` interface.
94
- *
95
- * @constructor
96
- * @public
97
- */
65
+ * Minimal `EventEmitter` interface that is molded against the Node.js
66
+ * `EventEmitter` interface.
67
+ *
68
+ * @constructor
69
+ * @public
70
+ */
98
71
  function EventEmitter() {
99
- this._events = new Events();
100
- this._eventsCount = 0;
72
+ this._events = new Events();
73
+ this._eventsCount = 0;
101
74
  }
102
-
103
75
  /**
104
- * Return an array listing the events for which the emitter has registered
105
- * listeners.
106
- *
107
- * @returns {Array}
108
- * @public
109
- */
76
+ * Return an array listing the events for which the emitter has registered
77
+ * listeners.
78
+ *
79
+ * @returns {Array}
80
+ * @public
81
+ */
110
82
  EventEmitter.prototype.eventNames = function eventNames() {
111
- var names = []
112
- , events
113
- , name;
114
-
115
- if (this._eventsCount === 0) return names;
116
-
117
- for (name in (events = this._events)) {
118
- if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
119
- }
120
-
121
- if (Object.getOwnPropertySymbols) {
122
- return names.concat(Object.getOwnPropertySymbols(events));
123
- }
124
-
125
- return names;
83
+ var names = [], events, name;
84
+ if (this._eventsCount === 0) return names;
85
+ for (name in events = this._events) if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
86
+ if (Object.getOwnPropertySymbols) return names.concat(Object.getOwnPropertySymbols(events));
87
+ return names;
126
88
  };
127
-
128
89
  /**
129
- * Return the listeners registered for a given event.
130
- *
131
- * @param {(String|Symbol)} event The event name.
132
- * @returns {Array} The registered listeners.
133
- * @public
134
- */
90
+ * Return the listeners registered for a given event.
91
+ *
92
+ * @param {(String|Symbol)} event The event name.
93
+ * @returns {Array} The registered listeners.
94
+ * @public
95
+ */
135
96
  EventEmitter.prototype.listeners = function listeners(event) {
136
- var evt = prefix ? prefix + event : event
137
- , handlers = this._events[evt];
138
-
139
- if (!handlers) return [];
140
- if (handlers.fn) return [handlers.fn];
141
-
142
- for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
143
- ee[i] = handlers[i].fn;
144
- }
145
-
146
- return ee;
97
+ var evt = prefix ? prefix + event : event, handlers = this._events[evt];
98
+ if (!handlers) return [];
99
+ if (handlers.fn) return [handlers.fn];
100
+ for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) ee[i] = handlers[i].fn;
101
+ return ee;
147
102
  };
148
-
149
103
  /**
150
- * Return the number of listeners listening to a given event.
151
- *
152
- * @param {(String|Symbol)} event The event name.
153
- * @returns {Number} The number of listeners.
154
- * @public
155
- */
104
+ * Return the number of listeners listening to a given event.
105
+ *
106
+ * @param {(String|Symbol)} event The event name.
107
+ * @returns {Number} The number of listeners.
108
+ * @public
109
+ */
156
110
  EventEmitter.prototype.listenerCount = function listenerCount(event) {
157
- var evt = prefix ? prefix + event : event
158
- , listeners = this._events[evt];
159
-
160
- if (!listeners) return 0;
161
- if (listeners.fn) return 1;
162
- return listeners.length;
111
+ var evt = prefix ? prefix + event : event, listeners = this._events[evt];
112
+ if (!listeners) return 0;
113
+ if (listeners.fn) return 1;
114
+ return listeners.length;
163
115
  };
164
-
165
116
  /**
166
- * Calls each of the listeners registered for a given event.
167
- *
168
- * @param {(String|Symbol)} event The event name.
169
- * @returns {Boolean} `true` if the event had listeners, else `false`.
170
- * @public
171
- */
117
+ * Calls each of the listeners registered for a given event.
118
+ *
119
+ * @param {(String|Symbol)} event The event name.
120
+ * @returns {Boolean} `true` if the event had listeners, else `false`.
121
+ * @public
122
+ */
172
123
  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
173
- var evt = prefix ? prefix + event : event;
174
-
175
- if (!this._events[evt]) return false;
176
-
177
- var listeners = this._events[evt]
178
- , len = arguments.length
179
- , args
180
- , i;
181
-
182
- if (listeners.fn) {
183
- if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
184
-
185
- switch (len) {
186
- case 1: return listeners.fn.call(listeners.context), true;
187
- case 2: return listeners.fn.call(listeners.context, a1), true;
188
- case 3: return listeners.fn.call(listeners.context, a1, a2), true;
189
- case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
190
- case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
191
- case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
192
- }
193
-
194
- for (i = 1, args = new Array(len -1); i < len; i++) {
195
- args[i - 1] = arguments[i];
196
- }
197
-
198
- listeners.fn.apply(listeners.context, args);
199
- } else {
200
- var length = listeners.length
201
- , j;
202
-
203
- for (i = 0; i < length; i++) {
204
- if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
205
-
206
- switch (len) {
207
- case 1: listeners[i].fn.call(listeners[i].context); break;
208
- case 2: listeners[i].fn.call(listeners[i].context, a1); break;
209
- case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
210
- case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
211
- default:
212
- if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
213
- args[j - 1] = arguments[j];
214
- }
215
-
216
- listeners[i].fn.apply(listeners[i].context, args);
217
- }
218
- }
219
- }
220
-
221
- return true;
124
+ var evt = prefix ? prefix + event : event;
125
+ if (!this._events[evt]) return false;
126
+ var listeners = this._events[evt], len = arguments.length, args, i;
127
+ if (listeners.fn) {
128
+ if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
129
+ switch (len) {
130
+ case 1: return listeners.fn.call(listeners.context), true;
131
+ case 2: return listeners.fn.call(listeners.context, a1), true;
132
+ case 3: return listeners.fn.call(listeners.context, a1, a2), true;
133
+ case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
134
+ case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
135
+ case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
136
+ }
137
+ for (i = 1, args = new Array(len - 1); i < len; i++) args[i - 1] = arguments[i];
138
+ listeners.fn.apply(listeners.context, args);
139
+ } else {
140
+ var length = listeners.length, j;
141
+ for (i = 0; i < length; i++) {
142
+ if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
143
+ switch (len) {
144
+ case 1:
145
+ listeners[i].fn.call(listeners[i].context);
146
+ break;
147
+ case 2:
148
+ listeners[i].fn.call(listeners[i].context, a1);
149
+ break;
150
+ case 3:
151
+ listeners[i].fn.call(listeners[i].context, a1, a2);
152
+ break;
153
+ case 4:
154
+ listeners[i].fn.call(listeners[i].context, a1, a2, a3);
155
+ break;
156
+ default:
157
+ if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) args[j - 1] = arguments[j];
158
+ listeners[i].fn.apply(listeners[i].context, args);
159
+ }
160
+ }
161
+ }
162
+ return true;
222
163
  };
223
-
224
164
  /**
225
- * Add a listener for a given event.
226
- *
227
- * @param {(String|Symbol)} event The event name.
228
- * @param {Function} fn The listener function.
229
- * @param {*} [context=this] The context to invoke the listener with.
230
- * @returns {EventEmitter} `this`.
231
- * @public
232
- */
165
+ * Add a listener for a given event.
166
+ *
167
+ * @param {(String|Symbol)} event The event name.
168
+ * @param {Function} fn The listener function.
169
+ * @param {*} [context=this] The context to invoke the listener with.
170
+ * @returns {EventEmitter} `this`.
171
+ * @public
172
+ */
233
173
  EventEmitter.prototype.on = function on(event, fn, context) {
234
- return addListener(this, event, fn, context, false);
174
+ return addListener(this, event, fn, context, false);
235
175
  };
236
-
237
176
  /**
238
- * Add a one-time listener for a given event.
239
- *
240
- * @param {(String|Symbol)} event The event name.
241
- * @param {Function} fn The listener function.
242
- * @param {*} [context=this] The context to invoke the listener with.
243
- * @returns {EventEmitter} `this`.
244
- * @public
245
- */
177
+ * Add a one-time listener for a given event.
178
+ *
179
+ * @param {(String|Symbol)} event The event name.
180
+ * @param {Function} fn The listener function.
181
+ * @param {*} [context=this] The context to invoke the listener with.
182
+ * @returns {EventEmitter} `this`.
183
+ * @public
184
+ */
246
185
  EventEmitter.prototype.once = function once(event, fn, context) {
247
- return addListener(this, event, fn, context, true);
186
+ return addListener(this, event, fn, context, true);
248
187
  };
249
-
250
188
  /**
251
- * Remove the listeners of a given event.
252
- *
253
- * @param {(String|Symbol)} event The event name.
254
- * @param {Function} fn Only remove the listeners that match this function.
255
- * @param {*} context Only remove the listeners that have this context.
256
- * @param {Boolean} once Only remove one-time listeners.
257
- * @returns {EventEmitter} `this`.
258
- * @public
259
- */
189
+ * Remove the listeners of a given event.
190
+ *
191
+ * @param {(String|Symbol)} event The event name.
192
+ * @param {Function} fn Only remove the listeners that match this function.
193
+ * @param {*} context Only remove the listeners that have this context.
194
+ * @param {Boolean} once Only remove one-time listeners.
195
+ * @returns {EventEmitter} `this`.
196
+ * @public
197
+ */
260
198
  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
261
- var evt = prefix ? prefix + event : event;
262
-
263
- if (!this._events[evt]) return this;
264
- if (!fn) {
265
- clearEvent(this, evt);
266
- return this;
267
- }
268
-
269
- var listeners = this._events[evt];
270
-
271
- if (listeners.fn) {
272
- if (
273
- listeners.fn === fn &&
274
- (!once || listeners.once) &&
275
- (!context || listeners.context === context)
276
- ) {
277
- clearEvent(this, evt);
278
- }
279
- } else {
280
- for (var i = 0, events = [], length = listeners.length; i < length; i++) {
281
- if (
282
- listeners[i].fn !== fn ||
283
- (once && !listeners[i].once) ||
284
- (context && listeners[i].context !== context)
285
- ) {
286
- events.push(listeners[i]);
287
- }
288
- }
289
-
290
- //
291
- // Reset the array, or remove it completely if we have no more listeners.
292
- //
293
- if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
294
- else clearEvent(this, evt);
295
- }
296
-
297
- return this;
199
+ var evt = prefix ? prefix + event : event;
200
+ if (!this._events[evt]) return this;
201
+ if (!fn) {
202
+ clearEvent(this, evt);
203
+ return this;
204
+ }
205
+ var listeners = this._events[evt];
206
+ if (listeners.fn) {
207
+ if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) clearEvent(this, evt);
208
+ } else {
209
+ for (var i = 0, events = [], length = listeners.length; i < length; i++) if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) events.push(listeners[i]);
210
+ if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
211
+ else clearEvent(this, evt);
212
+ }
213
+ return this;
298
214
  };
299
-
300
215
  /**
301
- * Remove all listeners, or those of the specified event.
302
- *
303
- * @param {(String|Symbol)} [event] The event name.
304
- * @returns {EventEmitter} `this`.
305
- * @public
306
- */
216
+ * Remove all listeners, or those of the specified event.
217
+ *
218
+ * @param {(String|Symbol)} [event] The event name.
219
+ * @returns {EventEmitter} `this`.
220
+ * @public
221
+ */
307
222
  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
308
- var evt;
309
-
310
- if (event) {
311
- evt = prefix ? prefix + event : event;
312
- if (this._events[evt]) clearEvent(this, evt);
313
- } else {
314
- this._events = new Events();
315
- this._eventsCount = 0;
316
- }
317
-
318
- return this;
223
+ var evt;
224
+ if (event) {
225
+ evt = prefix ? prefix + event : event;
226
+ if (this._events[evt]) clearEvent(this, evt);
227
+ } else {
228
+ this._events = new Events();
229
+ this._eventsCount = 0;
230
+ }
231
+ return this;
319
232
  };
320
-
321
- //
322
- // Alias methods names because people roll like that.
323
- //
324
233
  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
325
234
  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
326
-
327
- //
328
- // Expose the prefix.
329
- //
330
235
  EventEmitter.prefixed = prefix;
331
-
332
- //
333
- // Allow `EventEmitter` to be imported as module namespace.
334
- //
335
236
  EventEmitter.EventEmitter = EventEmitter;
336
-
337
- //
338
- // Expose the module.
339
- //
340
- {
341
- module.exports = EventEmitter;
237
+ module.exports = EventEmitter;
238
+ })({
239
+ get exports() {
240
+ return eventemitter3Exports;
241
+ },
242
+ set exports(v) {
243
+ eventemitter3Exports = v;
342
244
  }
343
- } (eventemitter3));
344
-
345
- const EventEmitter = eventemitter3Exports;
346
-
347
- class TimeoutError extends Error {
245
+ });
246
+ var eventemitter3_default = eventemitter3Exports;
247
+ //#endregion
248
+ //#region node_modules/p-timeout/index.js
249
+ var TimeoutError = class extends Error {
348
250
  constructor(message) {
349
251
  super(message);
350
- this.name = 'TimeoutError';
252
+ this.name = "TimeoutError";
351
253
  }
352
- }
353
-
254
+ };
354
255
  /**
355
256
  An error to be thrown when the request is aborted by AbortController.
356
257
  DOMException is thrown instead of this Error when DOMException is available.
357
258
  */
358
- let AbortError$1 = class AbortError extends Error {
259
+ var AbortError$1 = class extends Error {
359
260
  constructor(message) {
360
261
  super();
361
- this.name = 'AbortError';
262
+ this.name = "AbortError";
362
263
  this.message = message;
363
264
  }
364
265
  };
365
-
366
266
  /**
367
267
  TODO: Remove AbortError and just throw DOMException when targeting Node 18.
368
268
  */
369
- const getDOMException = errorMessage => globalThis.DOMException === undefined ?
370
- new AbortError$1(errorMessage) :
371
- new DOMException(errorMessage);
372
-
269
+ var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new AbortError$1(errorMessage) : new DOMException(errorMessage);
373
270
  /**
374
271
  TODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.
375
272
  */
376
- const getAbortedReason = signal => {
377
- const reason = signal.reason === undefined ?
378
- getDOMException('This operation was aborted.') :
379
- signal.reason;
380
-
273
+ var getAbortedReason = (signal) => {
274
+ const reason = signal.reason === void 0 ? getDOMException("This operation was aborted.") : signal.reason;
381
275
  return reason instanceof Error ? reason : getDOMException(reason);
382
276
  };
383
-
384
277
  function pTimeout(promise, milliseconds, fallback, options) {
385
278
  let timer;
386
-
387
279
  const cancelablePromise = new Promise((resolve, reject) => {
388
- if (typeof milliseconds !== 'number' || Math.sign(milliseconds) !== 1) {
389
- throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
390
- }
391
-
280
+ if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
392
281
  if (milliseconds === Number.POSITIVE_INFINITY) {
393
282
  resolve(promise);
394
283
  return;
395
284
  }
396
-
397
285
  options = {
398
- customTimers: {setTimeout, clearTimeout},
286
+ customTimers: {
287
+ setTimeout,
288
+ clearTimeout
289
+ },
399
290
  ...options
400
291
  };
401
-
402
292
  if (options.signal) {
403
- const {signal} = options;
404
- if (signal.aborted) {
405
- reject(getAbortedReason(signal));
406
- }
407
-
408
- signal.addEventListener('abort', () => {
293
+ const { signal } = options;
294
+ if (signal.aborted) reject(getAbortedReason(signal));
295
+ signal.addEventListener("abort", () => {
409
296
  reject(getAbortedReason(signal));
410
297
  });
411
298
  }
412
-
413
- timer = options.customTimers.setTimeout.call(undefined, () => {
414
- if (typeof fallback === 'function') {
299
+ timer = options.customTimers.setTimeout.call(void 0, () => {
300
+ if (typeof fallback === "function") {
415
301
  try {
416
302
  resolve(fallback());
417
303
  } catch (error) {
418
304
  reject(error);
419
305
  }
420
-
421
306
  return;
422
307
  }
423
-
424
- const message = typeof fallback === 'string' ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
308
+ const message = typeof fallback === "string" ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
425
309
  const timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message);
426
-
427
- if (typeof promise.cancel === 'function') {
428
- promise.cancel();
429
- }
430
-
310
+ if (typeof promise.cancel === "function") promise.cancel();
431
311
  reject(timeoutError);
432
312
  }, milliseconds);
433
-
434
313
  (async () => {
435
314
  try {
436
315
  resolve(await promise);
437
316
  } catch (error) {
438
317
  reject(error);
439
318
  } finally {
440
- options.customTimers.clearTimeout.call(undefined, timer);
319
+ options.customTimers.clearTimeout.call(void 0, timer);
441
320
  }
442
321
  })();
443
322
  });
444
-
445
323
  cancelablePromise.clear = () => {
446
324
  clearTimeout(timer);
447
- timer = undefined;
325
+ timer = void 0;
448
326
  };
449
-
450
327
  return cancelablePromise;
451
328
  }
452
-
453
- // Port of lower_bound from https://en.cppreference.com/w/cpp/algorithm/lower_bound
454
- // Used to compute insertion index to keep queue sorted after insertion
329
+ //#endregion
330
+ //#region node_modules/p-queue/dist/lower-bound.js
455
331
  function lowerBound(array, value, comparator) {
456
- let first = 0;
457
- let count = array.length;
458
- while (count > 0) {
459
- const step = Math.trunc(count / 2);
460
- let it = first + step;
461
- if (comparator(array[it], value) <= 0) {
462
- first = ++it;
463
- count -= step + 1;
464
- }
465
- else {
466
- count = step;
467
- }
468
- }
469
- return first;
332
+ let first = 0;
333
+ let count = array.length;
334
+ while (count > 0) {
335
+ const step = Math.trunc(count / 2);
336
+ let it = first + step;
337
+ if (comparator(array[it], value) <= 0) {
338
+ first = ++it;
339
+ count -= step + 1;
340
+ } else count = step;
341
+ }
342
+ return first;
470
343
  }
471
-
472
- var __classPrivateFieldGet$1 = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
473
- if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
474
- if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
475
- return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
344
+ //#endregion
345
+ //#region node_modules/p-queue/dist/priority-queue.js
346
+ var __classPrivateFieldGet$1 = function(receiver, state, kind, f) {
347
+ if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
348
+ if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
349
+ return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
476
350
  };
477
351
  var _PriorityQueue_queue;
478
- class PriorityQueue {
479
- constructor() {
480
- _PriorityQueue_queue.set(this, []);
481
- }
482
- enqueue(run, options) {
483
- options = {
484
- priority: 0,
485
- ...options,
486
- };
487
- const element = {
488
- priority: options.priority,
489
- run,
490
- };
491
- if (this.size && __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f")[this.size - 1].priority >= options.priority) {
492
- __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").push(element);
493
- return;
494
- }
495
- const index = lowerBound(__classPrivateFieldGet$1(this, _PriorityQueue_queue, "f"), element, (a, b) => b.priority - a.priority);
496
- __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").splice(index, 0, element);
497
- }
498
- dequeue() {
499
- const item = __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").shift();
500
- return item === null || item === undefined ? undefined : item.run;
501
- }
502
- filter(options) {
503
- return __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").filter((element) => element.priority === options.priority).map((element) => element.run);
504
- }
505
- get size() {
506
- return __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").length;
507
- }
508
- }
509
- _PriorityQueue_queue = new WeakMap();
510
-
511
- var __classPrivateFieldSet = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
512
- if (kind === "m") throw new TypeError("Private method is not writable");
513
- if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
514
- if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
515
- return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
352
+ var PriorityQueue = class {
353
+ constructor() {
354
+ _PriorityQueue_queue.set(this, []);
355
+ }
356
+ enqueue(run, options) {
357
+ options = {
358
+ priority: 0,
359
+ ...options
360
+ };
361
+ const element = {
362
+ priority: options.priority,
363
+ run
364
+ };
365
+ if (this.size && __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f")[this.size - 1].priority >= options.priority) {
366
+ __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").push(element);
367
+ return;
368
+ }
369
+ const index = lowerBound(__classPrivateFieldGet$1(this, _PriorityQueue_queue, "f"), element, (a, b) => b.priority - a.priority);
370
+ __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").splice(index, 0, element);
371
+ }
372
+ dequeue() {
373
+ const item = __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").shift();
374
+ return item === null || item === void 0 ? void 0 : item.run;
375
+ }
376
+ filter(options) {
377
+ return __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").filter((element) => element.priority === options.priority).map((element) => element.run);
378
+ }
379
+ get size() {
380
+ return __classPrivateFieldGet$1(this, _PriorityQueue_queue, "f").length;
381
+ }
382
+ };
383
+ _PriorityQueue_queue = /* @__PURE__ */ new WeakMap();
384
+ //#endregion
385
+ //#region node_modules/p-queue/dist/index.js
386
+ var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
387
+ if (kind === "m") throw new TypeError("Private method is not writable");
388
+ if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
389
+ if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
390
+ return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
516
391
  };
517
- var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
518
- if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
519
- if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
520
- return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
392
+ var __classPrivateFieldGet = function(receiver, state, kind, f) {
393
+ if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
394
+ if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
395
+ return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
521
396
  };
522
397
  var _PQueue_instances, _PQueue_carryoverConcurrencyCount, _PQueue_isIntervalIgnored, _PQueue_intervalCount, _PQueue_intervalCap, _PQueue_interval, _PQueue_intervalEnd, _PQueue_intervalId, _PQueue_timeoutId, _PQueue_queue, _PQueue_queueClass, _PQueue_pendingCount, _PQueue_concurrency, _PQueue_isPaused, _PQueue_throwOnTimeout, _PQueue_doesIntervalAllowAnother_get, _PQueue_doesConcurrentAllowAnother_get, _PQueue_next, _PQueue_emitEvents, _PQueue_onResumeInterval, _PQueue_isIntervalPaused_get, _PQueue_tryToStartAnother, _PQueue_initializeIntervalIfNeeded, _PQueue_onInterval, _PQueue_processQueue, _PQueue_onEvent;
523
- const timeoutError = new TimeoutError();
398
+ var timeoutError = new TimeoutError();
524
399
  /**
525
400
  The error thrown by `queue.add()` when a job is aborted before it is run. See `signal`.
526
401
  */
527
- class AbortError extends Error {
528
- }
402
+ var AbortError = class extends Error {};
529
403
  /**
530
404
  Promise queue with concurrency control.
531
405
  */
532
- class PQueue extends EventEmitter {
533
- constructor(options) {
534
- var _a, _b, _c, _d;
535
- super();
536
- _PQueue_instances.add(this);
537
- _PQueue_carryoverConcurrencyCount.set(this, undefined);
538
- _PQueue_isIntervalIgnored.set(this, undefined);
539
- _PQueue_intervalCount.set(this, 0);
540
- _PQueue_intervalCap.set(this, undefined);
541
- _PQueue_interval.set(this, undefined);
542
- _PQueue_intervalEnd.set(this, 0);
543
- _PQueue_intervalId.set(this, undefined);
544
- _PQueue_timeoutId.set(this, undefined);
545
- _PQueue_queue.set(this, undefined);
546
- _PQueue_queueClass.set(this, undefined);
547
- _PQueue_pendingCount.set(this, 0);
548
- // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
549
- _PQueue_concurrency.set(this, undefined);
550
- _PQueue_isPaused.set(this, undefined);
551
- _PQueue_throwOnTimeout.set(this, undefined);
552
- /**
553
- Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
554
-
555
- Applies to each future operation.
556
- */
557
- Object.defineProperty(this, "timeout", {
558
- enumerable: true,
559
- configurable: true,
560
- writable: true,
561
- value: undefined
562
- });
563
- // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
564
- options = {
565
- carryoverConcurrencyCount: false,
566
- intervalCap: Number.POSITIVE_INFINITY,
567
- interval: 0,
568
- concurrency: Number.POSITIVE_INFINITY,
569
- autoStart: true,
570
- queueClass: PriorityQueue,
571
- ...options,
572
- };
573
- if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {
574
- throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a = options.intervalCap) === null || _a === undefined ? undefined : _a.toString()) !== null && _b !== undefined ? _b : ''}\` (${typeof options.intervalCap})`);
575
- }
576
- if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
577
- throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${(_d = (_c = options.interval) === null || _c === undefined ? undefined : _c.toString()) !== null && _d !== undefined ? _d : ''}\` (${typeof options.interval})`);
578
- }
579
- __classPrivateFieldSet(this, _PQueue_carryoverConcurrencyCount, options.carryoverConcurrencyCount, "f");
580
- __classPrivateFieldSet(this, _PQueue_isIntervalIgnored, options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0, "f");
581
- __classPrivateFieldSet(this, _PQueue_intervalCap, options.intervalCap, "f");
582
- __classPrivateFieldSet(this, _PQueue_interval, options.interval, "f");
583
- __classPrivateFieldSet(this, _PQueue_queue, new options.queueClass(), "f");
584
- __classPrivateFieldSet(this, _PQueue_queueClass, options.queueClass, "f");
585
- this.concurrency = options.concurrency;
586
- this.timeout = options.timeout;
587
- __classPrivateFieldSet(this, _PQueue_throwOnTimeout, options.throwOnTimeout === true, "f");
588
- __classPrivateFieldSet(this, _PQueue_isPaused, options.autoStart === false, "f");
589
- }
590
- get concurrency() {
591
- return __classPrivateFieldGet(this, _PQueue_concurrency, "f");
592
- }
593
- set concurrency(newConcurrency) {
594
- if (!(typeof newConcurrency === 'number' && newConcurrency >= 1)) {
595
- throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
596
- }
597
- __classPrivateFieldSet(this, _PQueue_concurrency, newConcurrency, "f");
598
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
599
- }
600
- /**
601
- Adds a sync or async task to the queue. Always returns a promise.
602
- */
603
- async add(fn, options = {}) {
604
- return new Promise((resolve, reject) => {
605
- const run = async () => {
606
- var _a;
607
- var _b, _c;
608
- __classPrivateFieldSet(this, _PQueue_pendingCount, (_b = __classPrivateFieldGet(this, _PQueue_pendingCount, "f"), _b++, _b), "f");
609
- __classPrivateFieldSet(this, _PQueue_intervalCount, (_c = __classPrivateFieldGet(this, _PQueue_intervalCount, "f"), _c++, _c), "f");
610
- try {
611
- if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
612
- // TODO: Use ABORT_ERR code when targeting Node.js 16 (https://nodejs.org/docs/latest-v16.x/api/errors.html#abort_err)
613
- reject(new AbortError('The task was aborted.'));
614
- return;
615
- }
616
- const operation = (this.timeout === undefined && options.timeout === undefined) ? fn({ signal: options.signal }) : pTimeout(Promise.resolve(fn({ signal: options.signal })), (options.timeout === undefined ? this.timeout : options.timeout), () => {
617
- if (options.throwOnTimeout === undefined ? __classPrivateFieldGet(this, _PQueue_throwOnTimeout, "f") : options.throwOnTimeout) {
618
- reject(timeoutError);
619
- }
620
- return undefined;
621
- });
622
- const result = await operation;
623
- resolve(result);
624
- this.emit('completed', result);
625
- }
626
- catch (error) {
627
- reject(error);
628
- this.emit('error', error);
629
- }
630
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_next).call(this);
631
- };
632
- __classPrivateFieldGet(this, _PQueue_queue, "f").enqueue(run, options);
633
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this);
634
- this.emit('add');
635
- });
636
- }
637
- /**
638
- Same as `.add()`, but accepts an array of sync or async functions.
639
-
640
- @returns A promise that resolves when all functions are resolved.
641
- */
642
- async addAll(functions, options) {
643
- return Promise.all(functions.map(async (function_) => this.add(function_, options)));
644
- }
645
- /**
646
- Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
647
- */
648
- start() {
649
- if (!__classPrivateFieldGet(this, _PQueue_isPaused, "f")) {
650
- return this;
651
- }
652
- __classPrivateFieldSet(this, _PQueue_isPaused, false, "f");
653
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
654
- return this;
655
- }
656
- /**
657
- Put queue execution on hold.
658
- */
659
- pause() {
660
- __classPrivateFieldSet(this, _PQueue_isPaused, true, "f");
661
- }
662
- /**
663
- Clear the queue.
664
- */
665
- clear() {
666
- __classPrivateFieldSet(this, _PQueue_queue, new (__classPrivateFieldGet(this, _PQueue_queueClass, "f"))(), "f");
667
- }
668
- /**
669
- Can be called multiple times. Useful if you for example add additional items at a later time.
670
-
671
- @returns A promise that settles when the queue becomes empty.
672
- */
673
- async onEmpty() {
674
- // Instantly resolve if the queue is empty
675
- if (__classPrivateFieldGet(this, _PQueue_queue, "f").size === 0) {
676
- return;
677
- }
678
- await __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, 'empty');
679
- }
680
- /**
681
- @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
682
-
683
- If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
684
-
685
- Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
686
- */
687
- async onSizeLessThan(limit) {
688
- // Instantly resolve if the queue is empty.
689
- if (__classPrivateFieldGet(this, _PQueue_queue, "f").size < limit) {
690
- return;
691
- }
692
- await __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, 'next', () => __classPrivateFieldGet(this, _PQueue_queue, "f").size < limit);
693
- }
694
- /**
695
- The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
696
-
697
- @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
698
- */
699
- async onIdle() {
700
- // Instantly resolve if none pending and if nothing else is queued
701
- if (__classPrivateFieldGet(this, _PQueue_pendingCount, "f") === 0 && __classPrivateFieldGet(this, _PQueue_queue, "f").size === 0) {
702
- return;
703
- }
704
- await __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, 'idle');
705
- }
706
- /**
707
- Size of the queue, the number of queued items waiting to run.
708
- */
709
- get size() {
710
- return __classPrivateFieldGet(this, _PQueue_queue, "f").size;
711
- }
712
- /**
713
- Size of the queue, filtered by the given options.
714
-
715
- For example, this can be used to find the number of items remaining in the queue with a specific priority level.
716
- */
717
- sizeBy(options) {
718
- // eslint-disable-next-line unicorn/no-array-callback-reference
719
- return __classPrivateFieldGet(this, _PQueue_queue, "f").filter(options).length;
720
- }
721
- /**
722
- Number of running items (no longer in the queue).
723
- */
724
- get pending() {
725
- return __classPrivateFieldGet(this, _PQueue_pendingCount, "f");
726
- }
727
- /**
728
- Whether the queue is currently paused.
729
- */
730
- get isPaused() {
731
- return __classPrivateFieldGet(this, _PQueue_isPaused, "f");
732
- }
733
- }
734
- _PQueue_carryoverConcurrencyCount = new WeakMap(), _PQueue_isIntervalIgnored = new WeakMap(), _PQueue_intervalCount = new WeakMap(), _PQueue_intervalCap = new WeakMap(), _PQueue_interval = new WeakMap(), _PQueue_intervalEnd = new WeakMap(), _PQueue_intervalId = new WeakMap(), _PQueue_timeoutId = new WeakMap(), _PQueue_queue = new WeakMap(), _PQueue_queueClass = new WeakMap(), _PQueue_pendingCount = new WeakMap(), _PQueue_concurrency = new WeakMap(), _PQueue_isPaused = new WeakMap(), _PQueue_throwOnTimeout = new WeakMap(), _PQueue_instances = new WeakSet(), _PQueue_doesIntervalAllowAnother_get = function _PQueue_doesIntervalAllowAnother_get() {
735
- return __classPrivateFieldGet(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet(this, _PQueue_intervalCount, "f") < __classPrivateFieldGet(this, _PQueue_intervalCap, "f");
406
+ var PQueue = class extends eventemitter3_default {
407
+ constructor(options) {
408
+ var _a, _b, _c, _d;
409
+ super();
410
+ _PQueue_instances.add(this);
411
+ _PQueue_carryoverConcurrencyCount.set(this, void 0);
412
+ _PQueue_isIntervalIgnored.set(this, void 0);
413
+ _PQueue_intervalCount.set(this, 0);
414
+ _PQueue_intervalCap.set(this, void 0);
415
+ _PQueue_interval.set(this, void 0);
416
+ _PQueue_intervalEnd.set(this, 0);
417
+ _PQueue_intervalId.set(this, void 0);
418
+ _PQueue_timeoutId.set(this, void 0);
419
+ _PQueue_queue.set(this, void 0);
420
+ _PQueue_queueClass.set(this, void 0);
421
+ _PQueue_pendingCount.set(this, 0);
422
+ _PQueue_concurrency.set(this, void 0);
423
+ _PQueue_isPaused.set(this, void 0);
424
+ _PQueue_throwOnTimeout.set(this, void 0);
425
+ /**
426
+ Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
427
+
428
+ Applies to each future operation.
429
+ */
430
+ Object.defineProperty(this, "timeout", {
431
+ enumerable: true,
432
+ configurable: true,
433
+ writable: true,
434
+ value: void 0
435
+ });
436
+ options = {
437
+ carryoverConcurrencyCount: false,
438
+ intervalCap: Number.POSITIVE_INFINITY,
439
+ interval: 0,
440
+ concurrency: Number.POSITIVE_INFINITY,
441
+ autoStart: true,
442
+ queueClass: PriorityQueue,
443
+ ...options
444
+ };
445
+ if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ""}\` (${typeof options.intervalCap})`);
446
+ if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ""}\` (${typeof options.interval})`);
447
+ __classPrivateFieldSet(this, _PQueue_carryoverConcurrencyCount, options.carryoverConcurrencyCount, "f");
448
+ __classPrivateFieldSet(this, _PQueue_isIntervalIgnored, options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0, "f");
449
+ __classPrivateFieldSet(this, _PQueue_intervalCap, options.intervalCap, "f");
450
+ __classPrivateFieldSet(this, _PQueue_interval, options.interval, "f");
451
+ __classPrivateFieldSet(this, _PQueue_queue, new options.queueClass(), "f");
452
+ __classPrivateFieldSet(this, _PQueue_queueClass, options.queueClass, "f");
453
+ this.concurrency = options.concurrency;
454
+ this.timeout = options.timeout;
455
+ __classPrivateFieldSet(this, _PQueue_throwOnTimeout, options.throwOnTimeout === true, "f");
456
+ __classPrivateFieldSet(this, _PQueue_isPaused, options.autoStart === false, "f");
457
+ }
458
+ get concurrency() {
459
+ return __classPrivateFieldGet(this, _PQueue_concurrency, "f");
460
+ }
461
+ set concurrency(newConcurrency) {
462
+ if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
463
+ __classPrivateFieldSet(this, _PQueue_concurrency, newConcurrency, "f");
464
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
465
+ }
466
+ /**
467
+ Adds a sync or async task to the queue. Always returns a promise.
468
+ */
469
+ async add(fn, options = {}) {
470
+ return new Promise((resolve, reject) => {
471
+ const run = async () => {
472
+ var _a;
473
+ var _b, _c;
474
+ __classPrivateFieldSet(this, _PQueue_pendingCount, (_b = __classPrivateFieldGet(this, _PQueue_pendingCount, "f"), _b++, _b), "f");
475
+ __classPrivateFieldSet(this, _PQueue_intervalCount, (_c = __classPrivateFieldGet(this, _PQueue_intervalCount, "f"), _c++, _c), "f");
476
+ try {
477
+ if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
478
+ reject(new AbortError("The task was aborted."));
479
+ return;
480
+ }
481
+ const result = await (this.timeout === void 0 && options.timeout === void 0 ? fn({ signal: options.signal }) : pTimeout(Promise.resolve(fn({ signal: options.signal })), options.timeout === void 0 ? this.timeout : options.timeout, () => {
482
+ if (options.throwOnTimeout === void 0 ? __classPrivateFieldGet(this, _PQueue_throwOnTimeout, "f") : options.throwOnTimeout) reject(timeoutError);
483
+ }));
484
+ resolve(result);
485
+ this.emit("completed", result);
486
+ } catch (error) {
487
+ reject(error);
488
+ this.emit("error", error);
489
+ }
490
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_next).call(this);
491
+ };
492
+ __classPrivateFieldGet(this, _PQueue_queue, "f").enqueue(run, options);
493
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this);
494
+ this.emit("add");
495
+ });
496
+ }
497
+ /**
498
+ Same as `.add()`, but accepts an array of sync or async functions.
499
+
500
+ @returns A promise that resolves when all functions are resolved.
501
+ */
502
+ async addAll(functions, options) {
503
+ return Promise.all(functions.map(async (function_) => this.add(function_, options)));
504
+ }
505
+ /**
506
+ Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
507
+ */
508
+ start() {
509
+ if (!__classPrivateFieldGet(this, _PQueue_isPaused, "f")) return this;
510
+ __classPrivateFieldSet(this, _PQueue_isPaused, false, "f");
511
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
512
+ return this;
513
+ }
514
+ /**
515
+ Put queue execution on hold.
516
+ */
517
+ pause() {
518
+ __classPrivateFieldSet(this, _PQueue_isPaused, true, "f");
519
+ }
520
+ /**
521
+ Clear the queue.
522
+ */
523
+ clear() {
524
+ __classPrivateFieldSet(this, _PQueue_queue, new (__classPrivateFieldGet(this, _PQueue_queueClass, "f"))(), "f");
525
+ }
526
+ /**
527
+ Can be called multiple times. Useful if you for example add additional items at a later time.
528
+
529
+ @returns A promise that settles when the queue becomes empty.
530
+ */
531
+ async onEmpty() {
532
+ if (__classPrivateFieldGet(this, _PQueue_queue, "f").size === 0) return;
533
+ await __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, "empty");
534
+ }
535
+ /**
536
+ @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
537
+
538
+ If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
539
+
540
+ Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
541
+ */
542
+ async onSizeLessThan(limit) {
543
+ if (__classPrivateFieldGet(this, _PQueue_queue, "f").size < limit) return;
544
+ await __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, "next", () => __classPrivateFieldGet(this, _PQueue_queue, "f").size < limit);
545
+ }
546
+ /**
547
+ The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
548
+
549
+ @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
550
+ */
551
+ async onIdle() {
552
+ if (__classPrivateFieldGet(this, _PQueue_pendingCount, "f") === 0 && __classPrivateFieldGet(this, _PQueue_queue, "f").size === 0) return;
553
+ await __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, "idle");
554
+ }
555
+ /**
556
+ Size of the queue, the number of queued items waiting to run.
557
+ */
558
+ get size() {
559
+ return __classPrivateFieldGet(this, _PQueue_queue, "f").size;
560
+ }
561
+ /**
562
+ Size of the queue, filtered by the given options.
563
+
564
+ For example, this can be used to find the number of items remaining in the queue with a specific priority level.
565
+ */
566
+ sizeBy(options) {
567
+ return __classPrivateFieldGet(this, _PQueue_queue, "f").filter(options).length;
568
+ }
569
+ /**
570
+ Number of running items (no longer in the queue).
571
+ */
572
+ get pending() {
573
+ return __classPrivateFieldGet(this, _PQueue_pendingCount, "f");
574
+ }
575
+ /**
576
+ Whether the queue is currently paused.
577
+ */
578
+ get isPaused() {
579
+ return __classPrivateFieldGet(this, _PQueue_isPaused, "f");
580
+ }
581
+ };
582
+ _PQueue_carryoverConcurrencyCount = /* @__PURE__ */ new WeakMap(), _PQueue_isIntervalIgnored = /* @__PURE__ */ new WeakMap(), _PQueue_intervalCount = /* @__PURE__ */ new WeakMap(), _PQueue_intervalCap = /* @__PURE__ */ new WeakMap(), _PQueue_interval = /* @__PURE__ */ new WeakMap(), _PQueue_intervalEnd = /* @__PURE__ */ new WeakMap(), _PQueue_intervalId = /* @__PURE__ */ new WeakMap(), _PQueue_timeoutId = /* @__PURE__ */ new WeakMap(), _PQueue_queue = /* @__PURE__ */ new WeakMap(), _PQueue_queueClass = /* @__PURE__ */ new WeakMap(), _PQueue_pendingCount = /* @__PURE__ */ new WeakMap(), _PQueue_concurrency = /* @__PURE__ */ new WeakMap(), _PQueue_isPaused = /* @__PURE__ */ new WeakMap(), _PQueue_throwOnTimeout = /* @__PURE__ */ new WeakMap(), _PQueue_instances = /* @__PURE__ */ new WeakSet(), _PQueue_doesIntervalAllowAnother_get = function _PQueue_doesIntervalAllowAnother_get() {
583
+ return __classPrivateFieldGet(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet(this, _PQueue_intervalCount, "f") < __classPrivateFieldGet(this, _PQueue_intervalCap, "f");
736
584
  }, _PQueue_doesConcurrentAllowAnother_get = function _PQueue_doesConcurrentAllowAnother_get() {
737
- return __classPrivateFieldGet(this, _PQueue_pendingCount, "f") < __classPrivateFieldGet(this, _PQueue_concurrency, "f");
585
+ return __classPrivateFieldGet(this, _PQueue_pendingCount, "f") < __classPrivateFieldGet(this, _PQueue_concurrency, "f");
738
586
  }, _PQueue_next = function _PQueue_next() {
739
- var _a;
740
- __classPrivateFieldSet(this, _PQueue_pendingCount, (_a = __classPrivateFieldGet(this, _PQueue_pendingCount, "f"), _a--, _a), "f");
741
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this);
742
- this.emit('next');
587
+ var _a;
588
+ __classPrivateFieldSet(this, _PQueue_pendingCount, (_a = __classPrivateFieldGet(this, _PQueue_pendingCount, "f"), _a--, _a), "f");
589
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this);
590
+ this.emit("next");
743
591
  }, _PQueue_emitEvents = function _PQueue_emitEvents() {
744
- this.emit('empty');
745
- if (__classPrivateFieldGet(this, _PQueue_pendingCount, "f") === 0) {
746
- this.emit('idle');
747
- }
592
+ this.emit("empty");
593
+ if (__classPrivateFieldGet(this, _PQueue_pendingCount, "f") === 0) this.emit("idle");
748
594
  }, _PQueue_onResumeInterval = function _PQueue_onResumeInterval() {
749
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
750
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
751
- __classPrivateFieldSet(this, _PQueue_timeoutId, undefined, "f");
595
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
596
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
597
+ __classPrivateFieldSet(this, _PQueue_timeoutId, void 0, "f");
752
598
  }, _PQueue_isIntervalPaused_get = function _PQueue_isIntervalPaused_get() {
753
- const now = Date.now();
754
- if (__classPrivateFieldGet(this, _PQueue_intervalId, "f") === undefined) {
755
- const delay = __classPrivateFieldGet(this, _PQueue_intervalEnd, "f") - now;
756
- if (delay < 0) {
757
- // Act as the interval was done
758
- // We don't need to resume it here because it will be resumed on line 160
759
- __classPrivateFieldSet(this, _PQueue_intervalCount, (__classPrivateFieldGet(this, _PQueue_carryoverConcurrencyCount, "f")) ? __classPrivateFieldGet(this, _PQueue_pendingCount, "f") : 0, "f");
760
- }
761
- else {
762
- // Act as the interval is pending
763
- if (__classPrivateFieldGet(this, _PQueue_timeoutId, "f") === undefined) {
764
- __classPrivateFieldSet(this, _PQueue_timeoutId, setTimeout(() => {
765
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onResumeInterval).call(this);
766
- }, delay), "f");
767
- }
768
- return true;
769
- }
770
- }
771
- return false;
599
+ const now = Date.now();
600
+ if (__classPrivateFieldGet(this, _PQueue_intervalId, "f") === void 0) {
601
+ const delay = __classPrivateFieldGet(this, _PQueue_intervalEnd, "f") - now;
602
+ if (delay < 0) __classPrivateFieldSet(this, _PQueue_intervalCount, __classPrivateFieldGet(this, _PQueue_carryoverConcurrencyCount, "f") ? __classPrivateFieldGet(this, _PQueue_pendingCount, "f") : 0, "f");
603
+ else {
604
+ if (__classPrivateFieldGet(this, _PQueue_timeoutId, "f") === void 0) __classPrivateFieldSet(this, _PQueue_timeoutId, setTimeout(() => {
605
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onResumeInterval).call(this);
606
+ }, delay), "f");
607
+ return true;
608
+ }
609
+ }
610
+ return false;
772
611
  }, _PQueue_tryToStartAnother = function _PQueue_tryToStartAnother() {
773
- if (__classPrivateFieldGet(this, _PQueue_queue, "f").size === 0) {
774
- // We can clear the interval ("pause")
775
- // Because we can redo it later ("resume")
776
- if (__classPrivateFieldGet(this, _PQueue_intervalId, "f")) {
777
- clearInterval(__classPrivateFieldGet(this, _PQueue_intervalId, "f"));
778
- }
779
- __classPrivateFieldSet(this, _PQueue_intervalId, undefined, "f");
780
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_emitEvents).call(this);
781
- return false;
782
- }
783
- if (!__classPrivateFieldGet(this, _PQueue_isPaused, "f")) {
784
- const canInitializeInterval = !__classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_isIntervalPaused_get);
785
- if (__classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_doesIntervalAllowAnother_get) && __classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_doesConcurrentAllowAnother_get)) {
786
- const job = __classPrivateFieldGet(this, _PQueue_queue, "f").dequeue();
787
- if (!job) {
788
- return false;
789
- }
790
- this.emit('active');
791
- job();
792
- if (canInitializeInterval) {
793
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
794
- }
795
- return true;
796
- }
797
- }
798
- return false;
612
+ if (__classPrivateFieldGet(this, _PQueue_queue, "f").size === 0) {
613
+ if (__classPrivateFieldGet(this, _PQueue_intervalId, "f")) clearInterval(__classPrivateFieldGet(this, _PQueue_intervalId, "f"));
614
+ __classPrivateFieldSet(this, _PQueue_intervalId, void 0, "f");
615
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_emitEvents).call(this);
616
+ return false;
617
+ }
618
+ if (!__classPrivateFieldGet(this, _PQueue_isPaused, "f")) {
619
+ const canInitializeInterval = !__classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_isIntervalPaused_get);
620
+ if (__classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_doesIntervalAllowAnother_get) && __classPrivateFieldGet(this, _PQueue_instances, "a", _PQueue_doesConcurrentAllowAnother_get)) {
621
+ const job = __classPrivateFieldGet(this, _PQueue_queue, "f").dequeue();
622
+ if (!job) return false;
623
+ this.emit("active");
624
+ job();
625
+ if (canInitializeInterval) __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
626
+ return true;
627
+ }
628
+ }
629
+ return false;
799
630
  }, _PQueue_initializeIntervalIfNeeded = function _PQueue_initializeIntervalIfNeeded() {
800
- if (__classPrivateFieldGet(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet(this, _PQueue_intervalId, "f") !== undefined) {
801
- return;
802
- }
803
- __classPrivateFieldSet(this, _PQueue_intervalId, setInterval(() => {
804
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
805
- }, __classPrivateFieldGet(this, _PQueue_interval, "f")), "f");
806
- __classPrivateFieldSet(this, _PQueue_intervalEnd, Date.now() + __classPrivateFieldGet(this, _PQueue_interval, "f"), "f");
631
+ if (__classPrivateFieldGet(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet(this, _PQueue_intervalId, "f") !== void 0) return;
632
+ __classPrivateFieldSet(this, _PQueue_intervalId, setInterval(() => {
633
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
634
+ }, __classPrivateFieldGet(this, _PQueue_interval, "f")), "f");
635
+ __classPrivateFieldSet(this, _PQueue_intervalEnd, Date.now() + __classPrivateFieldGet(this, _PQueue_interval, "f"), "f");
807
636
  }, _PQueue_onInterval = function _PQueue_onInterval() {
808
- if (__classPrivateFieldGet(this, _PQueue_intervalCount, "f") === 0 && __classPrivateFieldGet(this, _PQueue_pendingCount, "f") === 0 && __classPrivateFieldGet(this, _PQueue_intervalId, "f")) {
809
- clearInterval(__classPrivateFieldGet(this, _PQueue_intervalId, "f"));
810
- __classPrivateFieldSet(this, _PQueue_intervalId, undefined, "f");
811
- }
812
- __classPrivateFieldSet(this, _PQueue_intervalCount, __classPrivateFieldGet(this, _PQueue_carryoverConcurrencyCount, "f") ? __classPrivateFieldGet(this, _PQueue_pendingCount, "f") : 0, "f");
813
- __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
637
+ if (__classPrivateFieldGet(this, _PQueue_intervalCount, "f") === 0 && __classPrivateFieldGet(this, _PQueue_pendingCount, "f") === 0 && __classPrivateFieldGet(this, _PQueue_intervalId, "f")) {
638
+ clearInterval(__classPrivateFieldGet(this, _PQueue_intervalId, "f"));
639
+ __classPrivateFieldSet(this, _PQueue_intervalId, void 0, "f");
640
+ }
641
+ __classPrivateFieldSet(this, _PQueue_intervalCount, __classPrivateFieldGet(this, _PQueue_carryoverConcurrencyCount, "f") ? __classPrivateFieldGet(this, _PQueue_pendingCount, "f") : 0, "f");
642
+ __classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
814
643
  }, _PQueue_processQueue = function _PQueue_processQueue() {
815
- // eslint-disable-next-line no-empty
816
- while (__classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this)) { }
644
+ while (__classPrivateFieldGet(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this));
817
645
  }, _PQueue_onEvent = async function _PQueue_onEvent(event, filter) {
818
- return new Promise(resolve => {
819
- const listener = () => {
820
- if (filter && !filter()) {
821
- return;
822
- }
823
- this.off(event, listener);
824
- resolve();
825
- };
826
- this.on(event, listener);
827
- });
646
+ return new Promise((resolve) => {
647
+ const listener = () => {
648
+ if (filter && !filter()) return;
649
+ this.off(event, listener);
650
+ resolve();
651
+ };
652
+ this.on(event, listener);
653
+ });
828
654
  };
829
-
830
- //#region \0rolldown/runtime.js
655
+ //#endregion
656
+ //#region node_modules/osra/build/index.js
831
657
  var e = Object.defineProperty, t = (t, n) => {
832
658
  let r = {};
833
659
  for (var i in t) e(r, i, {
834
660
  get: t[i],
835
- enumerable: true
661
+ enumerable: !0
836
662
  });
837
- return e(r, Symbol.toStringTag, { value: "Module" }), r;
838
- }, n = "__OSRA_KEY__", r = "__OSRA_DEFAULT_KEY__", i = "__OSRA_BOX__", a = () => globalThis.browser ?? globalThis.chrome, o = () => a()?.runtime, s = (e, t) => te(e) && e.__OSRA_KEY__ === t, c = (e, t) => {
663
+ return n || e(r, Symbol.toStringTag, { value: "Module" }), r;
664
+ }, n = "__OSRA_KEY__", r = "__OSRA_DEFAULT_KEY__", i = "__OSRA_BOX__", a = () => globalThis.browser ?? globalThis.chrome, o = () => a()?.runtime, s = (e, t) => C(e) && e.__OSRA_KEY__ === t, c = (e, t) => {
839
665
  if (e) {
840
666
  if (e.aborted) {
841
667
  t();
842
668
  return;
843
669
  }
844
- e.addEventListener("abort", t, { once: true });
670
+ e.addEventListener("abort", t, { once: !0 });
845
671
  }
846
672
  }, l = ({ listener: e, transport: t, remoteName: n, key: i = r, origin: a = "*", unregisterSignal: o }) => {
847
673
  if (o?.aborted) return;
848
- let l = M(t) ? t.receive : t;
674
+ let l = N(t) ? t.receive : t;
849
675
  if (typeof l == "function") {
850
676
  let t = l((t, r) => {
851
677
  o?.aborted || s(t, i) && (n && t.name !== n || e(t, r));
@@ -853,7 +679,7 @@ var e = Object.defineProperty, t = (t, n) => {
853
679
  typeof t == "function" && c(o, t);
854
680
  return;
855
681
  }
856
- if (w(l) || T(l) || E(l) || D(l)) {
682
+ if (E(l) || D(l) || O(l) || ie(l)) {
857
683
  let t = (t, r) => {
858
684
  let a = (t, a) => {
859
685
  s(t, i) && (n && t.name !== n || e(t, {
@@ -863,14 +689,14 @@ var e = Object.defineProperty, t = (t, n) => {
863
689
  };
864
690
  t.addListener(a), c(o, () => t.removeListener(a));
865
691
  };
866
- if (w(l)) t(l.onMessage);
867
- else if (E(l)) {
692
+ if (E(l)) t(l.onMessage);
693
+ else if (O(l)) {
868
694
  let e = (e) => t(e.onMessage, e);
869
695
  l.addListener(e), c(o, () => l.removeListener(e));
870
- } else D(l) ? t(l) : t(l.onMessage);
696
+ } else ie(l) ? t(l) : t(l.onMessage);
871
697
  return;
872
698
  }
873
- let u = x(l) ? l.port : l, d = a !== "*" && O(l), f = (t) => {
699
+ let u = x(l) ? l.port : l, d = a !== "*" && k(l), f = (t) => {
874
700
  let r = t.data;
875
701
  if (typeof r == "string") try {
876
702
  r = JSON.parse(r);
@@ -885,14 +711,16 @@ var e = Object.defineProperty, t = (t, n) => {
885
711
  };
886
712
  u.addEventListener("message", f), u instanceof MessagePort && u.start(), c(o, () => u.removeEventListener("message", f));
887
713
  }, u = (e, t, n = "*", r = []) => {
888
- let i = M(e) ? e.emit : e;
714
+ let i = N(e) ? e.emit : e;
889
715
  if (typeof i == "function") i(t, r);
890
- else if (O(i)) i.postMessage(t, n, r);
891
- else if (T(i)) i.postMessage(t);
892
- else if (w(i)) i.sendMessage(t);
716
+ else if (k(i)) i.postMessage(t, n, r);
717
+ else if (D(i)) i.postMessage(t);
718
+ else if (E(i)) i.sendMessage(t)?.catch?.((e) => {
719
+ if (!String(e?.message).includes("Receiving end does not exist")) throw e;
720
+ });
893
721
  else if (_(i)) {
894
722
  let e = JSON.stringify(t);
895
- i.readyState === WebSocket.CONNECTING ? i.addEventListener("open", () => i.send(e), { once: true }) : i.send(e);
723
+ i.readyState === WebSocket.CONNECTING ? i.addEventListener("open", () => i.send(e), { once: !0 }) : i.send(e);
896
724
  } else x(i) ? i.port.postMessage(t, r) : i.postMessage(t, r);
897
725
  }, d = globalThis.Float16Array, f = {
898
726
  Int8Array,
@@ -916,13 +744,13 @@ var e = Object.defineProperty, t = (t, n) => {
916
744
  let t = f[e];
917
745
  if (!t) throw Error("Unknown typed array type");
918
746
  return t;
919
- }, g = (e) => p.some((t) => !!t && e instanceof t), _ = (e) => e instanceof WebSocket, ee = (e) => !!globalThis.ServiceWorkerContainer && e instanceof ServiceWorkerContainer, v = (e) => !!globalThis.ServiceWorker && e instanceof ServiceWorker, y = (e) => !!globalThis.Worker && e instanceof Worker, b = (e) => {
747
+ }, g = (e) => p.some((t) => !!t && e instanceof t), _ = (e) => e instanceof WebSocket, v = (e) => !!globalThis.ServiceWorkerContainer && e instanceof ServiceWorkerContainer, ee = (e) => !!globalThis.ServiceWorker && e instanceof ServiceWorker, y = (e) => !!globalThis.Worker && e instanceof Worker, b = (e) => {
920
748
  let t = globalThis.DedicatedWorkerGlobalScope;
921
749
  return !!t && e instanceof t;
922
- }, x = (e) => !!globalThis.SharedWorker && e instanceof SharedWorker, S = (e) => e instanceof MessagePort, te = (e) => !!e && typeof e == "object" && "__OSRA_KEY__" in e && !!e.__OSRA_KEY__, C = (e, t) => {
923
- for (let n of t) if (n && e instanceof n) return true;
924
- return false;
925
- }, ne = (e) => C(e, [globalThis.SharedArrayBuffer]), ie = (e) => C(e, [
750
+ }, x = (e) => !!globalThis.SharedWorker && e instanceof SharedWorker, S = (e) => e instanceof MessagePort, C = (e) => !!e && typeof e == "object" && "__OSRA_KEY__" in e && !!e.__OSRA_KEY__, w = (e, t) => {
751
+ for (let n of t) if (n && e instanceof n) return !0;
752
+ return !1;
753
+ }, T = (e) => w(e, [globalThis.SharedArrayBuffer]), ne = (e) => w(e, [
926
754
  globalThis.ArrayBuffer,
927
755
  globalThis.MessagePort,
928
756
  globalThis.ReadableStream,
@@ -938,62 +766,61 @@ var e = Object.defineProperty, t = (t, n) => {
938
766
  globalThis.RTCDataChannel,
939
767
  globalThis.WebTransportReceiveStream,
940
768
  globalThis.WebTransportSendStream
941
- ]), w = (e) => {
769
+ ]), E = (e) => {
942
770
  let t = o();
943
- return t ? e === t : false;
944
- }, T = (e, t = false) => !e || typeof e != "object" || O(e) || !("name" in e) || !("disconnect" in e) || !("postMessage" in e) ? false : t ? "sender" in e && "onMessage" in e && "onDisconnect" in e : true, ae = (e) => !!e && typeof e == "object" && !O(e) && "addListener" in e && "hasListener" in e && "removeListener" in e, E = (e) => {
771
+ return t ? e === t : !1;
772
+ }, D = (e, t = !1) => !e || typeof e != "object" || k(e) || !("name" in e) || !("disconnect" in e) || !("postMessage" in e) ? !1 : t ? "sender" in e && "onMessage" in e && "onDisconnect" in e : !0, re = (e) => !!e && typeof e == "object" && !k(e) && "addListener" in e && "hasListener" in e && "removeListener" in e, O = (e) => {
945
773
  let t = o();
946
- return t ? e === t.onConnect || e === t.onConnectExternal : false;
947
- }, D = (e) => ae(e), O = (e) => {
948
- if (!e || typeof e != "object") return false;
774
+ return t ? e === t.onConnect || e === t.onConnectExternal : !1;
775
+ }, ie = (e) => re(e), k = (e) => {
776
+ if (!e || typeof e != "object") return !1;
949
777
  try {
950
778
  return "window" in e && e.window === e;
951
779
  } catch {
952
780
  try {
953
781
  return "closed" in e && typeof e.closed == "boolean" && "close" in e && typeof e.close == "function";
954
782
  } catch {
955
- return false;
783
+ return !1;
956
784
  }
957
785
  }
958
- }, oe = (e) => _(e) || T(e) || w(e), se = (e) => _(e) || T(e) || E(e) || D(e) || w(e), k = (e) => !!e && typeof e == "object" && !O(e) && "isJson" in e && e.isJson === true || oe(e) || se(e), A = (e) => O(e) || oe(e) || v(e) || y(e) || b(e) || x(e) || S(e) || de(e);
959
- var j = (e) => O(e) || se(e) || ee(e) || y(e) || b(e) || x(e) || S(e) || fe(e);
960
- var ue = (e) => {
961
- if (!e || typeof e != "object" || O(e)) return false;
786
+ }, ae = (e) => _(e) || D(e) || E(e), oe = (e) => _(e) || D(e) || O(e) || ie(e) || E(e), A = (e) => !!e && typeof e == "object" && !k(e) && "isJson" in e && e.isJson === !0 || ae(e) || oe(e), j = (e) => k(e) || ae(e) || ee(e) || y(e) || b(e) || x(e) || S(e) || ue(e);
787
+ var M = (e) => k(e) || oe(e) || v(e) || y(e) || b(e) || x(e) || S(e) || de(e), le = (e) => {
788
+ if (!e || typeof e != "object" || k(e)) return !1;
962
789
  let t = Object.getPrototypeOf(e);
963
790
  return t === Object.prototype || t === null;
964
- }, de = (e) => !ue(e) || !("emit" in e) ? false : A(e.emit) || typeof e.emit == "function", fe = (e) => !ue(e) || !("receive" in e) ? false : j(e.receive) || typeof e.receive == "function", M = (e) => de(e) || fe(e), N = { [i]: "revivable" }, P = (e) => !!e && typeof e == "object" && "__OSRA_BOX__" in e && e.__OSRA_BOX__ === "revivable", me = (e, t) => k(t.transport) ? { base64Buffer: new Uint8Array(e).toBase64() } : { arrayBuffer: e }, he = (e) => "arrayBuffer" in e ? e.arrayBuffer : Uint8Array.fromBase64(e.base64Buffer).buffer, ge = /* @__PURE__ */ t({
965
- box: () => ye,
966
- isType: () => ve,
967
- revive: () => be,
968
- type: () => _e
969
- }), _e = "arrayBuffer", ve = (e) => e instanceof ArrayBuffer, ye = (e, t) => ({
970
- ...N,
971
- type: _e,
972
- ...me(e, t)
973
- }), be = (e, t) => he(e), xe = /* @__PURE__ */ t({
974
- box: () => we,
975
- isType: () => Ce,
976
- revive: () => Te,
977
- type: () => Se
978
- }), Se = "date", Ce = (e) => e instanceof Date, we = (e, t) => ({
979
- ...N,
980
- type: Se,
791
+ }, ue = (e) => !le(e) || !("emit" in e) ? !1 : j(e.emit) || typeof e.emit == "function", de = (e) => !le(e) || !("receive" in e) ? !1 : M(e.receive) || typeof e.receive == "function", N = (e) => ue(e) || de(e), P = { [i]: "revivable" }, F = (e) => !!e && typeof e == "object" && "__OSRA_BOX__" in e && e.__OSRA_BOX__ === "revivable", pe = (e, t) => A(t.transport) ? { base64Buffer: new Uint8Array(e).toBase64() } : { arrayBuffer: e }, me = (e) => "arrayBuffer" in e ? e.arrayBuffer : Uint8Array.fromBase64(e.base64Buffer).buffer, he = /* @__PURE__ */ t({
792
+ box: () => ve,
793
+ isType: () => _e,
794
+ revive: () => ye,
795
+ type: () => ge
796
+ }), ge = "arrayBuffer", _e = (e) => e instanceof ArrayBuffer, ve = (e, t) => ({
797
+ ...P,
798
+ type: ge,
799
+ ...pe(e, t)
800
+ }), ye = (e, t) => me(e), be = /* @__PURE__ */ t({
801
+ box: () => Ce,
802
+ isType: () => Se,
803
+ revive: () => we,
804
+ type: () => xe
805
+ }), xe = "date", Se = (e) => e instanceof Date, Ce = (e, t) => ({
806
+ ...P,
807
+ type: xe,
981
808
  ISOString: e.toISOString()
982
- }), Te = (e, t) => new Date(e.ISOString), Ee = /* @__PURE__ */ t({
983
- box: () => ke,
984
- isType: () => Oe,
985
- revive: () => Ae,
986
- type: () => De
987
- }), De = "headers", Oe = (e) => e instanceof Headers, ke = (e, t) => ({
988
- ...N,
989
- type: De,
809
+ }), we = (e, t) => new Date(e.ISOString), Te = /* @__PURE__ */ t({
810
+ box: () => Oe,
811
+ isType: () => De,
812
+ revive: () => ke,
813
+ type: () => Ee
814
+ }), Ee = "headers", De = (e) => e instanceof Headers, Oe = (e, t) => ({
815
+ ...P,
816
+ type: Ee,
990
817
  entries: [...e.entries()]
991
- }), Ae = (e, t) => new Headers(e.entries), je = /* @__PURE__ */ t({
992
- box: () => Fe,
993
- isType: () => Pe,
994
- revive: () => Ie,
995
- type: () => Me
996
- }), Me = "error", Ne = {
818
+ }), ke = (e, t) => new Headers(e.entries), Ae = /* @__PURE__ */ t({
819
+ box: () => Pe,
820
+ isType: () => Ne,
821
+ revive: () => Fe,
822
+ type: () => je
823
+ }), je = "error", Me = {
997
824
  Error,
998
825
  TypeError,
999
826
  RangeError,
@@ -1001,20 +828,20 @@ var ue = (e) => {
1001
828
  ReferenceError,
1002
829
  EvalError,
1003
830
  URIError
1004
- }, Pe = (e) => e instanceof Error, Fe = (e, t) => {
1005
- let n = "cause" in e && e.cause !== undefined, r = typeof AggregateError < "u" && e instanceof AggregateError, i = typeof DOMException < "u" && e instanceof DOMException;
831
+ }, Ne = (e) => e instanceof Error, Pe = (e, t) => {
832
+ let n = "cause" in e && e.cause !== void 0, r = typeof AggregateError < "u" && e instanceof AggregateError, i = typeof DOMException < "u" && e instanceof DOMException;
1006
833
  return {
1007
- ...N,
1008
- type: Me,
834
+ ...P,
835
+ type: je,
1009
836
  name: e.name,
1010
837
  message: e.message,
1011
838
  stack: e.stack || e.toString(),
1012
- ...n ? { cause: X(e.cause, t) } : {},
1013
- ...r ? { errors: X(e.errors, t) } : {},
1014
- ...i ? { isDOMException: true } : {}
839
+ ...n ? { cause: Q(e.cause, t) } : {},
840
+ ...r ? { errors: Q(e.errors, t) } : {},
841
+ ...i ? { isDOMException: !0 } : {}
1015
842
  };
1016
- }, Ie = (e, t) => {
1017
- let n = e.cause === undefined ? undefined : Z(e.cause, t), r = n === undefined ? undefined : { cause: n };
843
+ }, Fe = (e, t) => {
844
+ let n = e.cause === void 0 ? void 0 : $(e.cause, t), r = n === void 0 ? void 0 : { cause: n };
1018
845
  if (e.isDOMException && typeof DOMException < "u") {
1019
846
  let t = new DOMException(e.message, e.name);
1020
847
  if (e.stack) try {
@@ -1026,62 +853,64 @@ var ue = (e) => {
1026
853
  return t;
1027
854
  }
1028
855
  let i;
1029
- if (e.errors !== undefined && typeof AggregateError < "u") i = AggregateError(Z(e.errors, t), e.message, r);
856
+ if (e.errors !== void 0 && typeof AggregateError < "u") i = AggregateError($(e.errors, t), e.message, r);
1030
857
  else {
1031
- let t = Ne[e.name] ?? Error;
1032
- i = r === undefined ? new t(e.message) : new t(e.message, r);
858
+ let t = Me[e.name] ?? Error;
859
+ i = r === void 0 ? new t(e.message) : new t(e.message, r);
1033
860
  }
1034
861
  return e.name && i.name !== e.name && (i.name = e.name), e.stack && (i.stack = e.stack), i;
1035
- }, Le = /* @__PURE__ */ t({
1036
- box: () => Be,
1037
- isType: () => ze,
1038
- revive: () => Ve,
1039
- type: () => Re
1040
- }), Re = "typedArray", ze = g, Be = (e, t) => {
862
+ }, Ie = /* @__PURE__ */ t({
863
+ box: () => ze,
864
+ isType: () => Re,
865
+ revive: () => Be,
866
+ type: () => Le
867
+ }), Le = "typedArray", Re = g, ze = (e, t) => {
1041
868
  let n = e.byteOffset === 0 && e.byteLength === e.buffer.byteLength ? e.buffer : e.buffer.slice(e.byteOffset, e.byteOffset + e.byteLength);
1042
869
  return {
1043
- ...N,
1044
- type: Re,
870
+ ...P,
871
+ type: Le,
1045
872
  typedArrayType: m(e),
1046
- ...me(n, t)
873
+ ...pe(n, t)
1047
874
  };
1048
- }, Ve = (e, t) => new (h(e.typedArrayType))(he(e)), F = /* @__PURE__ */ new WeakMap(), He = /* @__PURE__ */ new WeakSet(), I = (e, t) => {
1049
- if (He.has(e)) return t(), () => {};
1050
- let n = F.get(e);
1051
- return n || F.set(e, n = /* @__PURE__ */ new Set()), n.add(t), () => n.delete(t);
1052
- }, Ue = (e) => {
1053
- if (He.has(e)) return;
1054
- He.add(e);
1055
- let t = F.get(e);
875
+ }, Be = (e, t) => new (h(e.typedArrayType))(me(e)), I = /* @__PURE__ */ new WeakMap(), Ve = /* @__PURE__ */ new WeakSet(), L = (e, t) => {
876
+ if (Ve.has(e)) return t(), () => {};
877
+ let n = I.get(e);
878
+ return n || I.set(e, n = /* @__PURE__ */ new Set()), n.add(t), () => n.delete(t);
879
+ }, R = (e) => {
880
+ if (Ve.has(e)) return;
881
+ Ve.add(e);
882
+ let t = I.get(e);
1056
883
  if (t) {
1057
- F.delete(e);
884
+ I.delete(e);
1058
885
  for (let e of t) try {
1059
886
  e();
1060
887
  } catch {}
1061
888
  }
1062
- }, We = /* @__PURE__ */ t({
1063
- box: () => Qe,
1064
- isType: () => Ze,
1065
- revive: () => $e,
1066
- transfer: () => Xe,
1067
- type: () => Ge
1068
- }), Ge = "transfer", Ke = Symbol.for("osra.transfer"), qe = (e) => typeof e == "object" && !!e, Je = (e) => qe(e) && Ke in e && e[Ke] === true, Ye = (e) => qe(e) ? ArrayBuffer.isView(e) ? true : C(e, [
889
+ }, He = /* @__PURE__ */ t({
890
+ box: () => Xe,
891
+ isType: () => Ye,
892
+ revive: () => Ze,
893
+ transfer: () => Je,
894
+ type: () => Ue
895
+ }), Ue = "transfer", We = Symbol.for("osra.transfer"), Ge = (e) => typeof e == "object" && !!e, Ke = (e) => Ge(e) && We in e && e[We] === !0, qe = (e) => Ge(e) ? ArrayBuffer.isView(e) ? !0 : w(e, [
1069
896
  globalThis.ArrayBuffer,
1070
897
  globalThis.MessagePort,
1071
898
  globalThis.ReadableStream,
1072
899
  globalThis.WritableStream,
1073
900
  globalThis.TransformStream,
1074
901
  globalThis.ImageBitmap,
1075
- globalThis.OffscreenCanvas
1076
- ]) : false, Xe = (e) => Ye(e) ? {
1077
- [Ke]: true,
902
+ globalThis.OffscreenCanvas,
903
+ globalThis.VideoFrame,
904
+ globalThis.AudioData
905
+ ]) : !1, Je = (e) => qe(e) ? {
906
+ [We]: !0,
1078
907
  value: e
1079
- } : e, Ze = (e) => Je(e), Qe = (e, t) => ({
1080
- ...N,
1081
- type: Ge,
1082
- inner: X(e.value, t),
1083
- degraded: k(t.transport)
1084
- }), $e = (e, t) => Z(e.inner, t), et = (e) => C(e, [
908
+ } : e, Ye = (e) => Ke(e), Xe = (e, t) => ({
909
+ ...P,
910
+ type: Ue,
911
+ inner: Q(e.value, t),
912
+ degraded: A(t.transport)
913
+ }), Ze = (e, t) => $(e.inner, t), Qe = (e) => w(e, [
1085
914
  globalThis.MessagePort,
1086
915
  globalThis.ReadableStream,
1087
916
  globalThis.WritableStream,
@@ -1093,18 +922,18 @@ var ue = (e) => {
1093
922
  globalThis.RTCDataChannel,
1094
923
  globalThis.WebTransportReceiveStream,
1095
924
  globalThis.WebTransportSendStream
1096
- ]), tt = (e) => P(e) && e.type === "transfer", L = (e) => {
925
+ ]), $e = (e) => F(e) && e.type === "transfer", z = (e) => {
1097
926
  let t = [], n = /* @__PURE__ */ new WeakSet(), r = (e, i) => {
1098
- if (!(!e || typeof e != "object") && !n.has(e) && (n.add(e), !ne(e))) {
1099
- if (tt(e)) {
927
+ if (!(!e || typeof e != "object") && !n.has(e) && (n.add(e), !T(e))) {
928
+ if ($e(e)) {
1100
929
  r(e.inner, i || !e.degraded);
1101
930
  return;
1102
931
  }
1103
- if (et(e)) {
932
+ if (Qe(e)) {
1104
933
  t.push(e);
1105
934
  return;
1106
935
  }
1107
- if (ie(e)) {
936
+ if (ne(e)) {
1108
937
  i && t.push(e);
1109
938
  return;
1110
939
  }
@@ -1117,22 +946,21 @@ var ue = (e) => {
1117
946
  }
1118
947
  }
1119
948
  };
1120
- return r(e, false), t;
1121
- }, R = class {
949
+ return r(e, !1), t;
950
+ }, B = class {
1122
951
  _listeners = /* @__PURE__ */ new Map();
1123
- _onceListeners = /* @__PURE__ */ new WeakSet();
1124
952
  addEventListener(e, t, n) {
1125
953
  if (!t) return;
1126
954
  let r = this._listeners.get(e);
1127
- r || (r = /* @__PURE__ */ new Set(), this._listeners.set(e, r)), r.add(t), typeof n == "object" && n?.once && this._onceListeners.add(t);
955
+ r || (r = /* @__PURE__ */ new Map(), this._listeners.set(e, r)), r.has(t) || r.set(t, typeof n == "object" && !!n?.once);
1128
956
  }
1129
957
  removeEventListener(e, t, n) {
1130
- t && (this._listeners.get(e)?.delete(t), this._onceListeners.delete(t));
958
+ t && this._listeners.get(e)?.delete(t);
1131
959
  }
1132
960
  _peer;
1133
961
  _queue = [];
1134
- _started = false;
1135
- _closed = false;
962
+ _started = !1;
963
+ _closed = !1;
1136
964
  _onClose;
1137
965
  _onmessage = null;
1138
966
  get onmessage() {
@@ -1145,8 +973,8 @@ var ue = (e) => {
1145
973
  dispatchEvent(e) {
1146
974
  e.type === "message" ? this._onmessage?.call(this, e) : e.type === "messageerror" && this.onmessageerror?.call(this, e);
1147
975
  let t = this._listeners.get(e.type);
1148
- if (t) for (let n of [...t]) this._onceListeners.has(n) && (t.delete(n), this._onceListeners.delete(n)), typeof n == "function" ? n.call(this, e) : n.handleEvent(e);
1149
- return true;
976
+ if (t) for (let [n, r] of [...t]) r && t.delete(n), typeof n == "function" ? n.call(this, e) : n.handleEvent(e);
977
+ return !0;
1150
978
  }
1151
979
  postMessage(e, t) {
1152
980
  let n = this._peer;
@@ -1158,134 +986,193 @@ var ue = (e) => {
1158
986
  }
1159
987
  start() {
1160
988
  if (!this._started) {
1161
- this._started = true;
989
+ this._started = !0;
1162
990
  for (let e of this._queue.splice(0)) this.dispatchEvent(e);
1163
991
  }
1164
992
  }
1165
993
  close() {
1166
994
  if (this._closed) return;
1167
- this._closed = true, this._queue.length = 0, this._onClose?.();
995
+ this._closed = !0, this._queue.length = 0, this._onClose?.();
1168
996
  let e = this._peer;
1169
997
  e && !e._closed && queueMicrotask(() => {
1170
998
  e._closed || e.dispatchEvent(new Event("close"));
1171
999
  });
1172
1000
  }
1173
- }, z = class {
1001
+ }, V = class {
1174
1002
  port1;
1175
1003
  port2;
1176
1004
  constructor() {
1177
- let e = new R(), t = new R();
1005
+ let e = new B(), t = new B();
1178
1006
  e._peer = t, t._peer = e, this.port1 = e, this.port2 = t;
1179
1007
  }
1180
- }, nt = new FinalizationRegistry((e) => {
1008
+ }, et = new FinalizationRegistry((e) => {
1181
1009
  try {
1182
1010
  e();
1183
1011
  } catch {}
1184
- }), B = (e, t) => {
1012
+ }), H = (e, t) => {
1185
1013
  let n = {};
1186
- return nt.register(e, t, n), () => nt.unregister(n);
1187
- }, rt = /* @__PURE__ */ t({
1188
- box: () => H,
1189
- createRevivableChannel: () => W,
1190
- init: () => st,
1191
- isType: () => ct,
1192
- revive: () => U,
1193
- type: () => it
1194
- }), it = "messagePort", at = /* @__PURE__ */ new WeakMap(), ot = (e) => {
1195
- let t = at.get(e);
1014
+ return et.register(e, t, n), () => et.unregister(n);
1015
+ }, tt = /* @__PURE__ */ t({
1016
+ box: () => K,
1017
+ createRevivableChannel: () => J,
1018
+ init: () => dt,
1019
+ isType: () => ft,
1020
+ revive: () => q,
1021
+ type: () => nt
1022
+ }), nt = "messagePort", rt = 2048, it = 128, at = 1024, ot = /* @__PURE__ */ new WeakMap(), U = (e) => {
1023
+ let t = ot.get(e);
1196
1024
  if (!t) throw Error("osra message-port: connection state missing; did init() run?");
1197
1025
  return t;
1198
- }, st = (e) => {
1199
- let t = { portHandlers: /* @__PURE__ */ new Map() };
1200
- at.set(e, t), e.eventTarget.addEventListener("message", ({ detail: e }) => {
1201
- e.type !== "message" && e.type !== "message-port-close" || t.portHandlers.get(e.portId)?.(e);
1202
- }), I(e, () => {
1203
- for (let [n, r] of [...t.portHandlers]) r({
1026
+ }, st = (e, t) => {
1027
+ let n = e.ports.get(t);
1028
+ return n || (n = {
1029
+ nextSeq: 0,
1030
+ buffer: /* @__PURE__ */ new Map(),
1031
+ outSeq: 0
1032
+ }, e.ports.set(t, n), e.pendingPorts++), n;
1033
+ }, W = (e, t) => {
1034
+ let n = e.ports.get(t);
1035
+ if (n && !n.handler && e.pendingPorts--, e.ports.delete(t), e.tombstones.size >= it) {
1036
+ let t = e.tombstones.values().next().value;
1037
+ t !== void 0 && e.tombstones.delete(t);
1038
+ }
1039
+ e.tombstones.add(t);
1040
+ }, ct = (e) => {
1041
+ if (e.handler) for (let t = e.buffer.get(e.nextSeq); t !== void 0; t = e.buffer.get(e.nextSeq)) e.buffer.delete(e.nextSeq), e.nextSeq++, e.handler(t);
1042
+ }, lt = (e, t) => st(U(e), t).outSeq++, ut = (e, t, n) => {
1043
+ let r = U(e);
1044
+ if (r.tombstones.has(t)) {
1045
+ setTimeout(() => n({
1046
+ type: "message-port-close",
1047
+ remoteUuid: e.remoteUuid,
1048
+ portId: t
1049
+ }));
1050
+ return;
1051
+ }
1052
+ let i = st(r, t);
1053
+ i.handler || r.pendingPorts--, i.handler = n, ct(i);
1054
+ }, dt = (e) => {
1055
+ let t = {
1056
+ ports: /* @__PURE__ */ new Map(),
1057
+ tombstones: /* @__PURE__ */ new Set(),
1058
+ pendingPorts: 0
1059
+ };
1060
+ ot.set(e, t), e.eventTarget.addEventListener("message", ({ detail: n }) => {
1061
+ if (n.type !== "message" && n.type !== "message-port-close" || t.tombstones.has(n.portId)) return;
1062
+ let r = t.ports.get(n.portId);
1063
+ if (n.seq === void 0) {
1064
+ r?.handler?.(n);
1065
+ return;
1066
+ }
1067
+ if (!r) {
1068
+ if (t.pendingPorts >= at) return;
1069
+ r = st(t, n.portId);
1070
+ }
1071
+ if (!(n.seq < r.nextSeq)) {
1072
+ if (r.buffer.size >= rt && !(n.seq === r.nextSeq && r.handler)) {
1073
+ r.buffer.clear(), W(t, n.portId), r.handler?.({
1074
+ type: "message-port-close",
1075
+ remoteUuid: e.remoteUuid,
1076
+ portId: n.portId
1077
+ });
1078
+ return;
1079
+ }
1080
+ r.buffer.set(n.seq, n), ct(r);
1081
+ }
1082
+ }), L(e, () => {
1083
+ for (let [n, r] of [...t.ports]) r.handler?.({
1204
1084
  type: "message-port-close",
1205
1085
  remoteUuid: e.remoteUuid,
1206
1086
  portId: n
1207
1087
  });
1208
- t.portHandlers.clear();
1088
+ t.ports.clear(), t.tombstones.clear(), t.pendingPorts = 0;
1209
1089
  });
1210
- }, ct = (e) => e instanceof MessagePort || e instanceof R, V = (e, t) => {
1090
+ }, ft = (e) => e instanceof MessagePort || e instanceof B, G = (e, t) => {
1211
1091
  try {
1092
+ let n = U(e).ports.get(t);
1212
1093
  e.sendMessage({
1213
1094
  type: "message-port-close",
1214
1095
  remoteUuid: e.remoteUuid,
1215
- portId: t
1096
+ portId: t,
1097
+ seq: n ? n.outSeq++ : 0
1216
1098
  });
1217
1099
  } catch {}
1218
- }, lt = (e, t, n) => {
1219
- n ? e.postMessage(t) : e.postMessage(t, L(t));
1220
- }, H = (e, t, n) => {
1221
- let r = e instanceof R;
1222
- if (!r && !k(t.transport)) return {
1223
- ...N,
1224
- type: it,
1100
+ }, pt = (e, t, n) => {
1101
+ n ? e.postMessage(t) : e.postMessage(t, z(t));
1102
+ }, mt = (e, t, n) => () => {
1103
+ let r = e.deref();
1104
+ r && G(r, n);
1105
+ let i = t.deref();
1106
+ i && W(i, n);
1107
+ }, K = (e, t, n) => {
1108
+ let r = e instanceof B;
1109
+ if (!r && !A(t.transport)) return {
1110
+ ...P,
1111
+ type: nt,
1225
1112
  port: e,
1226
- ...n?.autoBox ? { autoBox: true } : {}
1113
+ ...n?.autoBox ? { autoBox: !0 } : {}
1227
1114
  };
1228
- let { portHandlers: i } = ot(t), a = e, o = globalThis.crypto.randomUUID(), s = new WeakRef(a), c = new WeakRef(t), l = new WeakRef(i), u = false, d = () => {
1115
+ let i = U(t), a = e, o = globalThis.crypto.randomUUID(), s = new WeakRef(a), c = new WeakRef(t), l = new WeakRef(i), u = !1, d = () => {
1229
1116
  if (u) return;
1230
- u = true, l.deref()?.delete(o), m?.();
1231
- let e = s.deref();
1232
- e?.removeEventListener("message", p), e instanceof R && (e._onClose = undefined);
1117
+ u = !0;
1118
+ let e = l.deref();
1119
+ e && W(e, o), m?.();
1120
+ let t = s.deref();
1121
+ t?.removeEventListener("message", p), t instanceof B && (t._onClose = void 0);
1233
1122
  }, f = (e) => {
1234
1123
  if (e.type === "message-port-close") {
1235
1124
  d(), a.dispatchEvent(new Event("close")), a.close();
1236
1125
  return;
1237
1126
  }
1238
- lt(a, Z(e.data, t), false);
1127
+ pt(a, $(e.data, t), !1);
1239
1128
  };
1240
1129
  function p({ data: e }) {
1241
1130
  t.sendMessage({
1242
1131
  type: "message",
1243
1132
  remoteUuid: t.remoteUuid,
1244
- data: X(e, t),
1245
- portId: o
1133
+ data: Q(e, t),
1134
+ portId: o,
1135
+ seq: lt(t, o)
1246
1136
  });
1247
1137
  }
1248
- let m = B(a, () => {
1249
- let e = c.deref();
1250
- e && V(e, o), d();
1251
- });
1252
- return a.addEventListener("message", p), a.start(), a instanceof R && (a._onClose = () => {
1253
- u || (V(t, o), d());
1254
- }), i.set(o, f), {
1255
- ...N,
1256
- type: it,
1138
+ let m = H(a, mt(c, l, o));
1139
+ return a.addEventListener("message", p), a.start(), a instanceof B && (a._onClose = () => {
1140
+ u || (G(t, o), d());
1141
+ }), ut(t, o, f), {
1142
+ ...P,
1143
+ type: nt,
1257
1144
  portId: o,
1258
1145
  synthetic: r
1259
1146
  };
1260
- }, U = (e, t) => "port" in e ? e.autoBox ? ut(e.port, t) : e.port : dt(e.portId, t, e.synthetic), ut = (e, t) => {
1147
+ }, q = (e, t) => "port" in e ? e.autoBox ? ht(e.port, t) : e.port : gt(e.portId, t, e.synthetic), ht = (e, t) => {
1261
1148
  let n = new EventTarget(), r = ({ data: e }) => {
1262
- n.dispatchEvent(new MessageEvent("message", { data: Z(e, t) }));
1149
+ n.dispatchEvent(new MessageEvent("message", { data: $(e, t) }));
1263
1150
  }, i = () => {
1264
1151
  n.dispatchEvent(new Event("close"));
1265
1152
  };
1266
1153
  return e.addEventListener("message", r), e.addEventListener("close", i), n.postMessage = (n, r) => {
1267
- let i = X(n, t), a = L(i), o = Array.isArray(r) ? r : [];
1154
+ let i = Q(n, t), a = z(i), o = Array.isArray(r) ? r : [];
1268
1155
  e.postMessage(i, o.length ? [...a, ...o] : a);
1269
1156
  }, n.start = () => e.start(), n.close = () => {
1270
1157
  e.removeEventListener("message", r), e.removeEventListener("close", i), e.close();
1271
1158
  }, n;
1272
- }, W = (e) => {
1273
- if (k(e.transport)) {
1274
- let { port1: t, port2: n } = new z();
1159
+ }, J = (e) => {
1160
+ if (A(e.transport)) {
1161
+ let { port1: t, port2: n } = new V();
1275
1162
  return {
1276
1163
  localPort: t,
1277
- boxedRemote: H(n, e)
1164
+ boxedRemote: K(n, e)
1278
1165
  };
1279
1166
  }
1280
1167
  let { port1: t, port2: n } = new MessageChannel();
1281
1168
  return {
1282
- localPort: ut(t, e),
1283
- boxedRemote: H(n, e, { autoBox: true })
1169
+ localPort: ht(t, e),
1170
+ boxedRemote: K(n, e, { autoBox: !0 })
1284
1171
  };
1285
- }, dt = (e, t, n) => {
1286
- let { portHandlers: r } = ot(t), { port1: i, port2: a } = n ? new z() : new MessageChannel(), o = new WeakRef(i), s = new WeakRef(a), c = false, l = () => {
1172
+ }, gt = (e, t, n) => {
1173
+ let r = U(t), { port1: i, port2: a } = n ? new V() : new MessageChannel(), o = new WeakRef(i), s = new WeakRef(a), c = !1, l = () => {
1287
1174
  if (c) return;
1288
- c = true, r.delete(e);
1175
+ c = !0, W(r, e);
1289
1176
  let t = s.deref();
1290
1177
  t?.removeEventListener("message", d), t?.close(), f?.();
1291
1178
  }, u = (e) => {
@@ -1300,28 +1187,29 @@ var ue = (e) => {
1300
1187
  return;
1301
1188
  }
1302
1189
  let r = s.deref();
1303
- r && lt(r, Z(e.data, t), n);
1190
+ r && pt(r, $(e.data, t), n);
1304
1191
  }, d = ({ data: n }) => {
1305
1192
  t.sendMessage({
1306
1193
  type: "message",
1307
1194
  remoteUuid: t.remoteUuid,
1308
- data: X(n, t),
1309
- portId: e
1195
+ data: Q(n, t),
1196
+ portId: e,
1197
+ seq: lt(t, e)
1310
1198
  });
1311
- }, f = B(i, () => {
1312
- V(t, e), l();
1199
+ }, f = H(i, () => {
1200
+ G(t, e), l();
1313
1201
  });
1314
- return i instanceof R && (i._onClose = () => {
1315
- c || (V(t, e), l());
1316
- }), a.addEventListener("message", d), a.start(), r.set(e, u), i;
1317
- }, ft = /* @__PURE__ */ t({
1318
- box: () => _t,
1319
- isType: () => gt,
1320
- revive: () => vt,
1321
- type: () => pt
1322
- }), pt = "promise", mt = (e) => e instanceof Promise, ht = /* @__PURE__ */ new Set(), gt = (e) => e instanceof Promise, _t = (e, t) => {
1323
- if (!mt(e)) throw TypeError("Expected Promise");
1324
- let { localPort: n, boxedRemote: r } = W(t), i = (e) => {
1202
+ return i instanceof B && (i._onClose = () => {
1203
+ c || (G(t, e), l());
1204
+ }), a.addEventListener("message", d), a.start(), ut(t, e, u), i;
1205
+ }, _t = /* @__PURE__ */ t({
1206
+ box: () => St,
1207
+ isType: () => xt,
1208
+ revive: () => Ct,
1209
+ type: () => vt
1210
+ }), vt = "promise", yt = (e) => e instanceof Promise, bt = /* @__PURE__ */ new Set(), xt = (e) => e instanceof Promise, St = (e, t) => {
1211
+ if (!yt(e)) throw TypeError("Expected Promise");
1212
+ let { localPort: n, boxedRemote: r } = J(t), i = (e) => {
1325
1213
  n.postMessage(e), n.close();
1326
1214
  };
1327
1215
  return e.then((e) => i({
@@ -1331,31 +1219,31 @@ var ue = (e) => {
1331
1219
  type: "reject",
1332
1220
  error: e
1333
1221
  })), {
1334
- ...N,
1335
- type: pt,
1222
+ ...P,
1223
+ type: vt,
1336
1224
  port: r
1337
1225
  };
1338
- }, vt = (e, t) => {
1339
- let n = U(e.port, t);
1340
- ht.add(n);
1226
+ }, Ct = (e, t) => {
1227
+ let n = q(e.port, t);
1228
+ bt.add(n);
1341
1229
  let r = "portId" in e.port;
1342
1230
  return new Promise((e, i) => {
1343
1231
  let a = () => {
1344
- n.close(), ht.delete(n), o();
1345
- }, o = r ? I(t, () => {
1232
+ n.close(), bt.delete(n), o();
1233
+ }, o = r ? L(t, () => {
1346
1234
  i(/* @__PURE__ */ Error("osra: connection closed")), a();
1347
1235
  }) : () => {};
1348
1236
  n.addEventListener("message", ({ data: t }) => {
1349
1237
  t.type === "resolve" ? e(t.data) : i(t.error), a();
1350
- }, { once: true }), n.start();
1238
+ }, { once: !0 }), n.start();
1351
1239
  });
1352
- }, yt = /* @__PURE__ */ t({
1353
- box: () => G,
1354
- isType: () => St,
1355
- revive: () => K,
1356
- type: () => bt
1357
- }), bt = "function", xt = /* @__PURE__ */ new Set(), St = (e) => typeof e == "function", G = (e, t) => {
1358
- let { port1: n, port2: r } = new z();
1240
+ }, wt = /* @__PURE__ */ t({
1241
+ box: () => Y,
1242
+ isType: () => Dt,
1243
+ revive: () => X,
1244
+ type: () => Tt
1245
+ }), Tt = "function", Et = /* @__PURE__ */ new Set(), Dt = (e) => typeof e == "function", Y = (e, t) => {
1246
+ let { port1: n, port2: r } = new V();
1359
1247
  return n.addEventListener("message", ({ data: n }) => {
1360
1248
  let [r, i] = n;
1361
1249
  (async () => {
@@ -1371,113 +1259,238 @@ var ue = (e) => {
1371
1259
  error: e
1372
1260
  };
1373
1261
  }
1374
- let a = X(n, t);
1375
- r.postMessage(a, L(a)), queueMicrotask(() => {
1262
+ let a = (() => {
1263
+ try {
1264
+ return Q(n, t);
1265
+ } catch (e) {
1266
+ return Q({
1267
+ type: "throw",
1268
+ error: e
1269
+ }, t);
1270
+ }
1271
+ })();
1272
+ r.postMessage(a, z(a)), queueMicrotask(() => {
1376
1273
  try {
1377
1274
  r.close();
1378
1275
  } catch {}
1379
1276
  });
1380
1277
  })();
1381
1278
  }), n.start(), {
1382
- ...N,
1383
- type: bt,
1384
- port: H(r, t)
1279
+ ...P,
1280
+ type: Tt,
1281
+ port: K(r, t)
1385
1282
  };
1386
- }, K = (e, t) => {
1387
- let n = U(e.port, t);
1283
+ }, X = (e, t) => {
1284
+ let n = q(e.port, t);
1388
1285
  return ((...e) => new Promise((r, i) => {
1389
- let { port1: a, port2: o } = new z();
1390
- xt.add(a);
1286
+ let { port1: a, port2: o } = new V();
1287
+ Et.add(a);
1391
1288
  let s = () => {
1392
- a.close(), xt.delete(a), c();
1393
- }, c = I(t, () => {
1289
+ a.close(), Et.delete(a), c();
1290
+ }, c = L(t, () => {
1394
1291
  i(/* @__PURE__ */ Error("osra: connection closed")), s();
1395
1292
  });
1396
1293
  a.addEventListener("message", ({ data: e }) => {
1397
1294
  let t = e;
1398
1295
  t.type === "return" ? r(t.value) : i(t.error), s();
1399
- }, { once: true }), a.start();
1400
- let l = X([o, e], t);
1401
- n.postMessage(l, L(l));
1296
+ }, { once: !0 }), a.start();
1297
+ let l = Q([o, e], t);
1298
+ n.postMessage(l, z(l));
1402
1299
  }));
1403
- }, Ct = /* @__PURE__ */ t({
1404
- box: () => Et,
1405
- isType: () => Tt,
1406
- revive: () => Dt,
1407
- type: () => wt
1408
- }), wt = "readableStream", Tt = (e) => e instanceof ReadableStream, Et = (e, t) => {
1409
- let { localPort: n, boxedRemote: r } = W(t), i = e.getReader();
1300
+ }, Ot = /* @__PURE__ */ t({
1301
+ MAX_CREDIT_WINDOW: () => 64,
1302
+ box: () => Pt,
1303
+ isType: () => At,
1304
+ revive: () => Rt,
1305
+ type: () => kt
1306
+ }), kt = "readableStream", At = (e) => e instanceof ReadableStream, jt = 2, Mt = 8, Nt = 4 * 1024 * 1024, Pt = (e, t) => {
1307
+ let { localPort: n, boxedRemote: r } = J(t), i = e.getReader(), a = 0, o = !1, s = !1, c = (e) => {
1308
+ s = !0;
1309
+ try {
1310
+ n.postMessage(e);
1311
+ } catch {}
1312
+ n.close();
1313
+ }, l = async () => {
1314
+ if (!(o || s)) {
1315
+ for (o = !0; a > 0;) {
1316
+ let e;
1317
+ try {
1318
+ e = await i.read();
1319
+ } catch (e) {
1320
+ s || c({
1321
+ type: "error",
1322
+ error: e
1323
+ });
1324
+ return;
1325
+ }
1326
+ if (s) return;
1327
+ if (e.done) {
1328
+ c({ type: "end" });
1329
+ return;
1330
+ }
1331
+ a--;
1332
+ try {
1333
+ n.postMessage({
1334
+ type: "chunk",
1335
+ value: e.value
1336
+ });
1337
+ } catch (e) {
1338
+ c({
1339
+ type: "error",
1340
+ error: e
1341
+ }), i.cancel(e).catch(() => {});
1342
+ return;
1343
+ }
1344
+ }
1345
+ o = !1;
1346
+ }
1347
+ };
1410
1348
  return n.addEventListener("message", ({ data: e }) => {
1411
- "type" in e && e.type === "pull" ? n.postMessage(i.read()) : (i.cancel("type" in e ? e.reason : undefined).catch(() => {}), n.close());
1349
+ e instanceof Promise || !("type" in e) || (e.type === "pull" ? n.postMessage(i.read()) : e.type === "credit" ? (a += e.n, l()) : e.type === "cancel" && (s = !0, i.cancel(e.reason).catch(() => {}), n.close()));
1412
1350
  }), n.addEventListener("close", () => {
1413
- i.cancel(/* @__PURE__ */ Error("osra: connection closed")).catch(() => {});
1414
- }, { once: true }), n.start(), {
1415
- ...N,
1416
- type: wt,
1351
+ s || (s = !0, i.cancel(/* @__PURE__ */ Error("osra: connection closed")).catch(() => {}));
1352
+ }, { once: !0 }), n.start(), {
1353
+ ...P,
1354
+ type: kt,
1355
+ credit: !0,
1417
1356
  port: r
1418
1357
  };
1419
- }, Dt = (e, t) => {
1420
- let n = U(e.port, t);
1421
- n.start();
1422
- let r = false;
1358
+ }, Ft = (e) => ArrayBuffer.isView(e) || e instanceof ArrayBuffer ? e.byteLength : typeof e == "string" ? e.length * 2 : typeof Blob < "u" && e instanceof Blob ? e.size : void 0, It = (e) => {
1359
+ let t = !1, n = 0, r, i = [], a = !1, o = !1, s, c, l = () => r === void 0 ? Mt : Math.max(jt, Math.min(64, Math.floor(Nt / r))), u = () => {
1360
+ let t = l(), r = n + i.length;
1361
+ if (r > t / 2) return;
1362
+ let a = t - r;
1363
+ n += a, e.postMessage({
1364
+ type: "credit",
1365
+ n: a
1366
+ });
1367
+ }, d = () => {
1368
+ t = !0, queueMicrotask(() => e.close());
1369
+ }, f = (e) => {
1370
+ if (o = !0, s = e, !c || i.length) return;
1371
+ let t = c;
1372
+ c = void 0, d(), t.reject(e);
1373
+ };
1423
1374
  return new ReadableStream({
1424
- start: (e) => {
1425
- n.addEventListener("close", () => {
1426
- if (!r) {
1427
- r = true;
1375
+ start: () => {
1376
+ e.addEventListener("message", ({ data: o }) => {
1377
+ if (!(o instanceof Promise || !("type" in o))) {
1378
+ if (o.type === "chunk") {
1379
+ if (t) return;
1380
+ if (n <= 0) {
1381
+ i.length = 0, f(/* @__PURE__ */ Error("osra: stream exceeded its credit window")), queueMicrotask(() => e.close());
1382
+ return;
1383
+ }
1384
+ n--;
1385
+ let a = Ft(o.value);
1386
+ if (a !== void 0 && (r = r === void 0 ? a : r * .875 + a * .125), c) {
1387
+ let e = c;
1388
+ c = void 0, e.controller.enqueue(o.value), e.resolve();
1389
+ } else i.push(o.value);
1390
+ } else if (o.type === "end") {
1391
+ if (t || (a = !0, !c || i.length)) return;
1392
+ let e = c;
1393
+ c = void 0, d(), e.controller.close(), e.resolve();
1394
+ } else if (o.type === "error") {
1395
+ if (t) return;
1396
+ f(o.error);
1397
+ }
1398
+ }
1399
+ }), e.addEventListener("close", () => {
1400
+ t || a || o || f(/* @__PURE__ */ Error("osra: connection closed"));
1401
+ }, { once: !0 });
1402
+ },
1403
+ pull: (e) => {
1404
+ if (!t) {
1405
+ if (i.length) {
1406
+ e.enqueue(i.shift()), !a && !o && u();
1407
+ return;
1408
+ }
1409
+ if (a) {
1410
+ d(), e.close();
1411
+ return;
1412
+ }
1413
+ return o ? (d(), Promise.reject(s)) : (u(), new Promise((t, n) => {
1414
+ c = {
1415
+ controller: e,
1416
+ resolve: t,
1417
+ reject: n
1418
+ };
1419
+ }));
1420
+ }
1421
+ },
1422
+ cancel: (n) => {
1423
+ t = !0, i.length = 0;
1424
+ let r = c;
1425
+ c = void 0, r?.resolve(), e.postMessage({
1426
+ type: "cancel",
1427
+ reason: n
1428
+ }), queueMicrotask(() => e.close());
1429
+ }
1430
+ });
1431
+ }, Lt = (e) => {
1432
+ let t = !1;
1433
+ return new ReadableStream({
1434
+ start: (n) => {
1435
+ e.addEventListener("close", () => {
1436
+ if (!t) {
1437
+ t = !0;
1428
1438
  try {
1429
- e.error(/* @__PURE__ */ Error("osra: connection closed"));
1439
+ n.error(/* @__PURE__ */ Error("osra: connection closed"));
1430
1440
  } catch {}
1431
1441
  }
1432
- }, { once: true });
1442
+ }, { once: !0 });
1433
1443
  },
1434
- pull: (e) => new Promise((t, i) => {
1435
- n.addEventListener("message", ({ data: a }) => {
1444
+ pull: (n) => new Promise((r, i) => {
1445
+ e.addEventListener("message", ({ data: a }) => {
1436
1446
  a instanceof Promise && a.then((i) => {
1437
- i.done ? (r = true, e.close(), n.postMessage({ type: "cancel" }), queueMicrotask(() => n.close())) : e.enqueue(i.value), t();
1447
+ i.done ? (t = !0, n.close(), e.postMessage({ type: "cancel" }), queueMicrotask(() => e.close())) : n.enqueue(i.value), r();
1438
1448
  }).catch((e) => {
1439
- r = true, i(e);
1449
+ t = !0, i(e);
1440
1450
  });
1441
- }, { once: true }), n.postMessage({ type: "pull" });
1451
+ }, { once: !0 }), e.postMessage({ type: "pull" });
1442
1452
  }),
1443
- cancel: (e) => {
1444
- r = true, n.postMessage({
1453
+ cancel: (n) => {
1454
+ t = !0, e.postMessage({
1445
1455
  type: "cancel",
1446
- reason: e
1447
- }), queueMicrotask(() => n.close());
1456
+ reason: n
1457
+ }), queueMicrotask(() => e.close());
1448
1458
  }
1449
1459
  });
1450
- }, Ot = /* @__PURE__ */ t({
1451
- box: () => jt,
1452
- isType: () => At,
1453
- revive: () => Mt,
1454
- type: () => kt
1455
- }), kt = "writableStream", At = (e) => e instanceof WritableStream, jt = (e, t) => {
1456
- let { localPort: n, boxedRemote: r } = W(t), i = e.getWriter(), a = false, o = (e, t) => e.then(() => n.postMessage({ type: "ack" })).catch((e) => n.postMessage({
1460
+ }, Rt = (e, t) => {
1461
+ let n = q(e.port, t);
1462
+ return n.start(), e.credit ? It(n) : Lt(n);
1463
+ }, zt = /* @__PURE__ */ t({
1464
+ box: () => Ht,
1465
+ isType: () => Vt,
1466
+ revive: () => Ut,
1467
+ type: () => Bt
1468
+ }), Bt = "writableStream", Vt = (e) => e instanceof WritableStream, Ht = (e, t) => {
1469
+ let { localPort: n, boxedRemote: r } = J(t), i = e.getWriter(), a = !1, o = (e, t) => e.then(() => n.postMessage({ type: "ack" })).catch((e) => n.postMessage({
1457
1470
  type: "err",
1458
1471
  error: e?.message ?? String(e)
1459
1472
  })).then(() => {
1460
- t && (a = true, queueMicrotask(() => n.close()));
1473
+ t && (a = !0, queueMicrotask(() => n.close()));
1461
1474
  });
1462
1475
  return n.addEventListener("message", ({ data: e }) => {
1463
- !e || typeof e != "object" || !("type" in e) || (e.type === "write" ? o(i.write(e.chunk), false) : e.type === "close" ? o(i.close(), true) : e.type === "abort" && o(i.abort(e.reason), true));
1476
+ !e || typeof e != "object" || !("type" in e) || (e.type === "write" ? o(i.write(e.chunk), !1) : e.type === "close" ? o(i.close(), !0) : e.type === "abort" && o(i.abort(e.reason), !0));
1464
1477
  }), n.addEventListener("close", () => {
1465
- a || (a = true, i.abort(/* @__PURE__ */ Error("osra: connection closed")).catch(() => {}));
1466
- }, { once: true }), n.start(), {
1467
- ...N,
1468
- type: kt,
1478
+ a || (a = !0, i.abort(/* @__PURE__ */ Error("osra: connection closed")).catch(() => {}));
1479
+ }, { once: !0 }), n.start(), {
1480
+ ...P,
1481
+ type: Bt,
1469
1482
  port: r
1470
1483
  };
1471
- }, Mt = (e, t) => {
1472
- let n = U(e.port, t);
1484
+ }, Ut = (e, t) => {
1485
+ let n = q(e.port, t);
1473
1486
  n.start();
1474
- let r = /* @__PURE__ */ new Set(), i = false;
1487
+ let r = /* @__PURE__ */ new Set(), i = !1;
1475
1488
  n.addEventListener("close", () => {
1476
- i = true;
1489
+ i = !0;
1477
1490
  let e = /* @__PURE__ */ Error("osra: connection closed");
1478
1491
  for (let t of [...r]) t(e);
1479
1492
  r.clear();
1480
- }, { once: true });
1493
+ }, { once: !0 });
1481
1494
  let a = Promise.resolve(), o = (e) => {
1482
1495
  let t = a.then(() => new Promise((t, a) => {
1483
1496
  if (i) {
@@ -1489,7 +1502,7 @@ var ue = (e) => {
1489
1502
  };
1490
1503
  r.add(a), n.addEventListener("message", ({ data: e }) => {
1491
1504
  !e || typeof e != "object" || !("type" in e) || (e.type === "ack" ? o(t) : e.type === "err" && o(() => a(Error(e.error))));
1492
- }, { once: true }), n.postMessage(e);
1505
+ }, { once: !0 }), n.postMessage(e);
1493
1506
  }));
1494
1507
  return a = t.catch(() => {}), t;
1495
1508
  };
@@ -1504,80 +1517,82 @@ var ue = (e) => {
1504
1517
  reason: e
1505
1518
  })
1506
1519
  });
1507
- }, Nt = /* @__PURE__ */ t({
1508
- box: () => Lt,
1509
- isType: () => Ft,
1510
- revive: () => Rt,
1511
- type: () => Pt
1512
- }), Pt = "abortSignal", Ft = (e) => e instanceof AbortSignal, It = /* @__PURE__ */ new WeakMap(), Lt = (e, t) => {
1520
+ }, Wt = /* @__PURE__ */ t({
1521
+ box: () => Jt,
1522
+ isType: () => Kt,
1523
+ revive: () => Yt,
1524
+ type: () => Gt
1525
+ }), Gt = "abortSignal", Kt = (e) => e instanceof AbortSignal, qt = /* @__PURE__ */ new WeakMap(), Jt = (e, t) => {
1513
1526
  if (e.aborted) return {
1514
- ...N,
1515
- type: Pt,
1516
- aborted: true,
1517
- reason: X(e.reason, t)
1527
+ ...P,
1528
+ type: Gt,
1529
+ aborted: !0,
1530
+ reason: Q(e.reason, t)
1518
1531
  };
1519
- let { localPort: n, boxedRemote: r } = W(t), i = () => {
1532
+ let { localPort: n, boxedRemote: r } = J(t), i = () => {
1520
1533
  n.postMessage({
1521
1534
  type: "abort",
1522
1535
  reason: e.reason
1523
1536
  }), n.close(), a();
1524
- }, a = I(t, () => {
1537
+ }, a = L(t, () => {
1525
1538
  e.removeEventListener("abort", i), n.close();
1526
1539
  });
1527
- return e.addEventListener("abort", i, { once: true }), {
1528
- ...N,
1529
- type: Pt,
1530
- aborted: false,
1531
- reason: undefined,
1540
+ return e.addEventListener("abort", i, { once: !0 }), {
1541
+ ...P,
1542
+ type: Gt,
1543
+ aborted: !1,
1544
+ reason: void 0,
1532
1545
  port: r
1533
1546
  };
1534
- }, Rt = (e, t) => {
1547
+ }, Yt = (e, t) => {
1535
1548
  let n = new AbortController();
1536
- if (e.aborted || e.port === undefined) return n.abort(Z(e.reason, t)), n.signal;
1537
- let r = U(e.port, t);
1538
- return It.set(n.signal, r), r.start(), r.addEventListener("message", ({ data: e }) => {
1539
- e.type === "abort" && (n.abort(Z(e.reason, t)), It.delete(n.signal), r.close());
1549
+ if (e.aborted || e.port === void 0) return n.abort($(e.reason, t)), n.signal;
1550
+ let r = q(e.port, t);
1551
+ return qt.set(n.signal, r), r.start(), r.addEventListener("message", ({ data: e }) => {
1552
+ e.type === "abort" && (n.abort($(e.reason, t)), qt.delete(n.signal), r.close());
1540
1553
  }), n.signal;
1541
- }, zt = /* @__PURE__ */ t({
1542
- box: () => Ht,
1543
- isType: () => Vt,
1544
- revive: () => Ut,
1545
- type: () => Bt
1546
- }), Bt = "response", Vt = (e) => e instanceof Response, Ht = (e, t) => ({
1547
- ...N,
1548
- type: Bt,
1554
+ }, Xt = /* @__PURE__ */ t({
1555
+ box: () => $t,
1556
+ isType: () => Qt,
1557
+ revive: () => en,
1558
+ type: () => Zt
1559
+ }), Zt = "response", Qt = (e) => e instanceof Response, $t = (e, t) => ({
1560
+ ...P,
1561
+ type: Zt,
1549
1562
  status: e.status,
1550
1563
  statusText: e.statusText,
1551
- headers: ke(e.headers),
1552
- body: e.body ? Et(e.body, t) : null,
1564
+ headers: Oe(e.headers, t),
1565
+ body: e.body ? Pt(e.body, t) : null,
1553
1566
  url: e.url,
1554
1567
  redirected: e.redirected
1555
- }), Ut = (e, t) => {
1568
+ }), en = (e, t) => {
1556
1569
  if (e.status === 0) return Response.error();
1557
- let n = Ae(e.headers), r = e.body ? Dt(e.body, t) : null, i = new Response(r, {
1570
+ let n = ke(e.headers, t), r = e.body ? Rt(e.body, t) : null, i = e.status === 101 || e.status === 204 || e.status === 205 || e.status === 304;
1571
+ r && i && r.cancel().catch(() => {});
1572
+ let a = new Response(i ? null : r, {
1558
1573
  status: e.status,
1559
1574
  statusText: e.statusText,
1560
1575
  headers: n
1561
1576
  });
1562
- return e.url && Object.defineProperty(i, "url", {
1577
+ return e.url && Object.defineProperty(a, "url", {
1563
1578
  value: e.url,
1564
- configurable: true
1565
- }), e.redirected && Object.defineProperty(i, "redirected", {
1566
- value: true,
1567
- configurable: true
1568
- }), i;
1569
- }, Wt = /* @__PURE__ */ t({
1570
- box: () => qt,
1571
- isType: () => Kt,
1572
- revive: () => Jt,
1573
- type: () => Gt
1574
- }), Gt = "request", Kt = (e) => e instanceof Request, qt = (e, t) => ({
1575
- ...N,
1576
- type: Gt,
1579
+ configurable: !0
1580
+ }), e.redirected && Object.defineProperty(a, "redirected", {
1581
+ value: !0,
1582
+ configurable: !0
1583
+ }), a;
1584
+ }, tn = /* @__PURE__ */ t({
1585
+ box: () => an,
1586
+ isType: () => rn,
1587
+ revive: () => on,
1588
+ type: () => nn
1589
+ }), nn = "request", rn = (e) => e instanceof Request, an = (e, t) => ({
1590
+ ...P,
1591
+ type: nn,
1577
1592
  method: e.method,
1578
1593
  url: e.url,
1579
- headers: ke(e.headers),
1580
- body: e.body ? Et(e.body, t) : null,
1594
+ headers: Oe(e.headers, t),
1595
+ body: e.body ? Pt(e.body, t) : null,
1581
1596
  credentials: e.credentials,
1582
1597
  cache: e.cache,
1583
1598
  mode: e.mode,
@@ -1586,9 +1601,9 @@ var ue = (e) => {
1586
1601
  referrerPolicy: e.referrerPolicy,
1587
1602
  integrity: e.integrity,
1588
1603
  keepalive: e.keepalive,
1589
- signal: Lt(e.signal, t)
1590
- }), Jt = (e, t) => {
1591
- let n = Ae(e.headers), r = {
1604
+ signal: Jt(e.signal, t)
1605
+ }), on = (e, t) => {
1606
+ let n = ke(e.headers, t), r = {
1592
1607
  method: e.method,
1593
1608
  headers: n,
1594
1609
  credentials: e.credentials,
@@ -1598,31 +1613,31 @@ var ue = (e) => {
1598
1613
  referrerPolicy: e.referrerPolicy,
1599
1614
  integrity: e.integrity,
1600
1615
  keepalive: e.keepalive,
1601
- signal: Rt(e.signal, t)
1616
+ signal: Yt(e.signal, t)
1602
1617
  };
1603
- return e.mode !== "navigate" && (r.mode = e.mode), e.body && (r.body = Dt(e.body, t), r.duplex = "half"), new Request(e.url, r);
1604
- }, Yt = /* @__PURE__ */ t({
1605
- box: () => sn,
1606
- boxByReference: () => cn,
1607
- identity: () => Y,
1608
- isType: () => an,
1609
- revive: () => ln,
1610
- type: () => q
1611
- }), q = "identity", Xt = Symbol.for("osra.identity"), Zt = (e) => e !== null && (typeof e == "object" || typeof e == "function"), J = (e) => {
1612
- if (e === null) return false;
1618
+ return e.mode !== "navigate" && (r.mode = e.mode), e.body && (r.body = Rt(e.body, t), r.duplex = "half"), new Request(e.url, r);
1619
+ }, sn = /* @__PURE__ */ t({
1620
+ box: () => bn,
1621
+ boxByReference: () => xn,
1622
+ identity: () => mn,
1623
+ isType: () => vn,
1624
+ revive: () => Sn,
1625
+ type: () => Z
1626
+ }), Z = "identity", cn = Symbol.for("osra.identity"), ln = (e) => e !== null && (typeof e == "object" || typeof e == "function"), un = (e) => {
1627
+ if (e === null) return !1;
1613
1628
  let t = typeof e;
1614
- return t === "object" || t === "function" ? true : t === "symbol" ? Symbol.keyFor(e) === undefined : false;
1615
- }, Qt = (e) => Zt(e) && Xt in e && e[Xt] === true, $t = /* @__PURE__ */ new WeakMap(), en = (e) => {
1616
- if (Qt(e)) return e;
1617
- let t = $t.get(e);
1629
+ return t === "object" || t === "function" ? !0 : t === "symbol" ? Symbol.keyFor(e) === void 0 : !1;
1630
+ }, dn = (e) => ln(e) && cn in e && e[cn] === !0, fn = /* @__PURE__ */ new WeakMap(), pn = (e) => {
1631
+ if (dn(e)) return e;
1632
+ let t = fn.get(e);
1618
1633
  if (t) return t;
1619
1634
  let n = {
1620
- [Xt]: true,
1635
+ [cn]: !0,
1621
1636
  value: e
1622
1637
  };
1623
- return $t.set(e, n), n;
1624
- }, Y = (e) => Zt(e) ? en(e) : e, tn = /* @__PURE__ */ new WeakMap(), nn = (e) => {
1625
- let t = tn.get(e);
1638
+ return fn.set(e, n), n;
1639
+ }, mn = (e) => ln(e) ? pn(e) : e, hn = /* @__PURE__ */ new WeakMap(), gn = (e) => {
1640
+ let t = hn.get(e);
1626
1641
  if (t) return t;
1627
1642
  let n = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new WeakMap(), o = {
1628
1643
  sendIds: n,
@@ -1639,113 +1654,113 @@ var ue = (e) => {
1639
1654
  }),
1640
1655
  receiveCache: i,
1641
1656
  revivedToId: a,
1642
- listenerInstalled: false
1657
+ listenerInstalled: !1
1643
1658
  };
1644
- return tn.set(e, o), rn(e, o), I(e, () => {
1659
+ return hn.set(e, o), _n(e, o), L(e, () => {
1645
1660
  o.receiveCache.clear(), o.idToSent.clear();
1646
1661
  }), o;
1647
- }, rn = (e, t) => {
1648
- t.listenerInstalled || (t.listenerInstalled = true, e.eventTarget.addEventListener("message", ({ detail: e }) => {
1662
+ }, _n = (e, t) => {
1663
+ t.listenerInstalled || (t.listenerInstalled = !0, e.eventTarget.addEventListener("message", ({ detail: e }) => {
1649
1664
  if (e?.type !== "identity-dispose") return;
1650
1665
  let n = t.receiveCache.get(e.id);
1651
- t.receiveCache.delete(e.id), n !== undefined && J(n) && t.revivedToId.delete(n);
1666
+ t.receiveCache.delete(e.id), n !== void 0 && un(n) && t.revivedToId.delete(n);
1652
1667
  }));
1653
- }, an = (e) => Qt(e), on = (e, t) => {
1668
+ }, vn = (e) => dn(e), yn = (e, t) => {
1654
1669
  let n = t.sendIds.get(e);
1655
- if (n !== undefined) return {
1670
+ if (n !== void 0) return {
1656
1671
  id: n,
1657
- isExisting: true
1672
+ isExisting: !0
1658
1673
  };
1659
1674
  let r = t.revivedToId.get(e);
1660
- if (r !== undefined) return {
1675
+ if (r !== void 0) return {
1661
1676
  id: r,
1662
- isExisting: true
1677
+ isExisting: !0
1663
1678
  };
1664
1679
  let i = globalThis.crypto.randomUUID();
1665
1680
  return t.sendIds.set(e, i), t.idToSent.set(i, new WeakRef(e)), t.sendRegistry.register(e, i), {
1666
1681
  id: i,
1667
- isExisting: false
1682
+ isExisting: !1
1668
1683
  };
1669
- }, sn = (e, t) => {
1670
- let n = nn(t), r = e.value, i = X(r, t);
1671
- if (!J(r)) return {
1672
- ...N,
1673
- type: q,
1684
+ }, bn = (e, t) => {
1685
+ let n = gn(t), r = e.value, i = Q(r, t);
1686
+ if (!un(r)) return {
1687
+ ...P,
1688
+ type: Z,
1674
1689
  id: globalThis.crypto.randomUUID(),
1675
1690
  inner: i
1676
1691
  };
1677
- let { id: a, isExisting: o } = on(r, n);
1692
+ let { id: a, isExisting: o } = yn(r, n);
1678
1693
  return o ? {
1679
- ...N,
1680
- type: q,
1694
+ ...P,
1695
+ type: Z,
1681
1696
  id: a
1682
1697
  } : {
1683
- ...N,
1684
- type: q,
1698
+ ...P,
1699
+ type: Z,
1685
1700
  id: a,
1686
1701
  inner: i
1687
1702
  };
1688
- }, cn = (e, t, n) => {
1689
- let { id: r, isExisting: i } = on(e, nn(n));
1703
+ }, xn = (e, t, n) => {
1704
+ let { id: r, isExisting: i } = yn(e, gn(n));
1690
1705
  return i ? {
1691
- ...N,
1692
- type: q,
1706
+ ...P,
1707
+ type: Z,
1693
1708
  id: r
1694
1709
  } : {
1695
- ...N,
1696
- type: q,
1710
+ ...P,
1711
+ type: Z,
1697
1712
  id: r,
1698
1713
  inner: t
1699
1714
  };
1700
- }, ln = (e, t) => {
1701
- let n = nn(t), r = n.receiveCache.get(e.id);
1702
- if (r !== undefined) return r;
1715
+ }, Sn = (e, t) => {
1716
+ let n = gn(t), r = n.receiveCache.get(e.id);
1717
+ if (r !== void 0) return r;
1703
1718
  let i = n.idToSent.get(e.id)?.deref();
1704
- if (i !== undefined) return i;
1705
- if (!("inner" in e) || e.inner === undefined) throw Error(`osra identity: received id=${e.id} with no inner payload and no cached value`);
1706
- let a = Z(e.inner, t);
1707
- return n.receiveCache.set(e.id, a), J(a) && n.revivedToId.set(a, e.id), a;
1708
- }, un = /* @__PURE__ */ t({
1709
- box: () => fn,
1710
- isType: () => dn,
1711
- revive: () => pn,
1719
+ if (i !== void 0) return i;
1720
+ if (!("inner" in e) || e.inner === void 0) throw Error(`osra identity: received id=${e.id} with no inner payload and no cached value`);
1721
+ let a = $(e.inner, t);
1722
+ return n.receiveCache.set(e.id, a), un(a) && n.revivedToId.set(a, e.id), a;
1723
+ }, Cn = /* @__PURE__ */ t({
1724
+ box: () => Tn,
1725
+ isType: () => wn,
1726
+ revive: () => En,
1712
1727
  type: () => "map"
1713
- }), dn = (e) => e instanceof Map, fn = (e, t) => ({
1714
- ...N,
1728
+ }), wn = (e) => e instanceof Map, Tn = (e, t) => ({
1729
+ ...P,
1715
1730
  type: "map",
1716
- entries: Array.from(e, ([e, n]) => [X(e, t), X(n, t)])
1717
- }), pn = (e, t) => new Map(e.entries.map(([e, n]) => [Z(e, t), Z(n, t)])), mn = /* @__PURE__ */ t({
1718
- box: () => gn,
1719
- isType: () => hn,
1720
- revive: () => _n,
1731
+ entries: Array.from(e, ([e, n]) => [Q(e, t), Q(n, t)])
1732
+ }), En = (e, t) => new Map(e.entries.map(([e, n]) => [$(e, t), $(n, t)])), Dn = /* @__PURE__ */ t({
1733
+ box: () => kn,
1734
+ isType: () => On,
1735
+ revive: () => An,
1721
1736
  type: () => "set"
1722
- }), hn = (e) => e instanceof Set, gn = (e, t) => ({
1723
- ...N,
1737
+ }), On = (e) => e instanceof Set, kn = (e, t) => ({
1738
+ ...P,
1724
1739
  type: "set",
1725
- values: Array.from(e, (e) => X(e, t))
1726
- }), _n = (e, t) => new Set(e.values.map((e) => Z(e, t))), vn = /* @__PURE__ */ t({
1727
- box: () => xn,
1728
- isType: () => bn,
1729
- revive: () => Sn,
1730
- type: () => yn
1731
- }), yn = "bigint", bn = (e) => typeof e == "bigint", xn = (e, t) => ({
1732
- ...N,
1733
- type: yn,
1740
+ values: Array.from(e, (e) => Q(e, t))
1741
+ }), An = (e, t) => new Set(e.values.map((e) => $(e, t))), jn = /* @__PURE__ */ t({
1742
+ box: () => Pn,
1743
+ isType: () => Nn,
1744
+ revive: () => Fn,
1745
+ type: () => Mn
1746
+ }), Mn = "bigint", Nn = (e) => typeof e == "bigint", Pn = (e, t) => ({
1747
+ ...P,
1748
+ type: Mn,
1734
1749
  value: e.toString()
1735
- }), Sn = (e, t) => BigInt(e.value), Cn = /* @__PURE__ */ t({
1736
- box: () => En,
1737
- isType: () => Tn,
1738
- revive: () => Dn,
1739
- type: () => wn
1740
- }), wn = "event", Tn = (e) => e instanceof Event, En = (e, t) => ({
1741
- ...N,
1742
- type: wn,
1750
+ }), Fn = (e, t) => BigInt(e.value), In = /* @__PURE__ */ t({
1751
+ box: () => zn,
1752
+ isType: () => Rn,
1753
+ revive: () => Bn,
1754
+ type: () => Ln
1755
+ }), Ln = "event", Rn = (e) => e instanceof Event, zn = (e, t) => ({
1756
+ ...P,
1757
+ type: Ln,
1743
1758
  eventType: e.type,
1744
1759
  bubbles: e.bubbles,
1745
1760
  cancelable: e.cancelable,
1746
1761
  composed: e.composed,
1747
- ...e instanceof CustomEvent ? { detail: X(e.detail, t) } : {}
1748
- }), Dn = (e, t) => {
1762
+ ...e instanceof CustomEvent ? { detail: Q(e.detail, t) } : {}
1763
+ }), Bn = (e, t) => {
1749
1764
  let n = {
1750
1765
  bubbles: e.bubbles,
1751
1766
  cancelable: e.cancelable,
@@ -1753,119 +1768,102 @@ var ue = (e) => {
1753
1768
  };
1754
1769
  return "detail" in e ? new CustomEvent(e.eventType, {
1755
1770
  ...n,
1756
- detail: Z(e.detail, t)
1771
+ detail: $(e.detail, t)
1757
1772
  }) : new Event(e.eventType, n);
1758
- }, On = /* @__PURE__ */ t({
1759
- box: () => jn,
1760
- isType: () => An,
1761
- revive: () => Fn,
1762
- type: () => kn
1763
- }), kn = "eventTarget", An = (e) => e instanceof EventTarget, jn = (e, t) => {
1773
+ }, Vn = /* @__PURE__ */ t({
1774
+ box: () => Wn,
1775
+ isType: () => Un,
1776
+ revive: () => Jn,
1777
+ type: () => Hn
1778
+ }), Hn = "eventTarget", Un = (e) => e instanceof EventTarget, Wn = (e, t) => {
1764
1779
  let n = [], r = (e) => typeof e == "boolean" ? e : !!e?.capture;
1765
1780
  return {
1766
- ...N,
1767
- type: kn,
1768
- addListener: G((t, i, a) => {
1781
+ ...P,
1782
+ type: Hn,
1783
+ addListener: Y((t, i, a) => {
1769
1784
  n.push({
1770
1785
  eventType: t,
1771
1786
  listener: i,
1772
1787
  capture: r(a)
1773
1788
  }), e.addEventListener(t, i, a);
1774
1789
  }, t),
1775
- removeListener: G((t, i, a) => {
1790
+ removeListener: Y((t, i, a) => {
1776
1791
  let o = r(a), s = n.findIndex((e) => e.eventType === t && e.listener === i && e.capture === o);
1777
1792
  s !== -1 && n.splice(s, 1), e.removeEventListener(t, i, a);
1778
1793
  }, t),
1779
- removeAllListeners: G(() => {
1794
+ removeAllListeners: Y(() => {
1780
1795
  for (let { eventType: t, listener: r, capture: i } of n.splice(0)) e.removeEventListener(t, r, { capture: i });
1781
1796
  }, t)
1782
1797
  };
1783
- }, Mn = /* @__PURE__ */ new WeakMap(), Nn = (e) => {
1798
+ }, Gn = /* @__PURE__ */ new WeakMap(), Kn = (e) => {
1784
1799
  if (typeof e == "function") return e;
1785
- let t = Mn.get(e);
1786
- return t || Mn.set(e, t = (t) => e.handleEvent(t)), t;
1787
- }, Pn = (e, t, n, r) => e.find((e) => e.eventType === t && e.listener === n && e.capture === r), Fn = (e, t) => {
1788
- let n = K(e.addListener, t), r = K(e.removeListener, t), i = K(e.removeAllListeners, t), a = new EventTarget(), o = [], s = (e) => {
1800
+ let t = Gn.get(e);
1801
+ return t || Gn.set(e, t = (t) => e.handleEvent(t)), t;
1802
+ }, qn = (e, t, n, r) => e.find((e) => e.eventType === t && e.listener === n && e.capture === r), Jn = (e, t) => {
1803
+ let n = X(e.addListener, t), r = X(e.removeListener, t), i = X(e.removeAllListeners, t), a = new EventTarget(), o = [], s = (e) => {
1789
1804
  let t = o.indexOf(e);
1790
1805
  t !== -1 && o.splice(t, 1);
1791
1806
  };
1792
1807
  return Object.defineProperty(a, "addEventListener", { value: (e, t, r) => {
1793
1808
  if (t === null) return;
1794
- let i = Nn(t), a = typeof r == "boolean" ? r : !!r?.capture;
1795
- if (Pn(o, e, i, a)) return;
1809
+ let i = Kn(t), a = typeof r == "boolean" ? r : !!r?.capture;
1810
+ if (qn(o, e, i, a)) return;
1796
1811
  let c = typeof r == "object" && r?.once ? (e) => (s(l), i(e)) : i, l = {
1797
1812
  eventType: e,
1798
1813
  listener: i,
1799
1814
  capture: a,
1800
1815
  wire: c
1801
1816
  };
1802
- o.push(l), (typeof r == "object" ? r?.signal : undefined)?.addEventListener("abort", () => s(l), { once: true }), n(e, Y(c), r).catch(() => {});
1817
+ o.push(l), (typeof r == "object" ? r?.signal : void 0)?.addEventListener("abort", () => s(l), { once: !0 }), n(e, mn(c), r).catch(() => {});
1803
1818
  } }), Object.defineProperty(a, "removeEventListener", { value: (e, t, n) => {
1804
1819
  if (t === null) return;
1805
- let i = Nn(t), a = typeof n == "boolean" ? n : !!n?.capture, c = Pn(o, e, i, a);
1806
- c && (s(c), r(e, Y(c.wire), { capture: a }).catch(() => {}));
1807
- } }), B(a, () => {
1820
+ let i = Kn(t), a = typeof n == "boolean" ? n : !!n?.capture, c = qn(o, e, i, a);
1821
+ c && (s(c), r(e, mn(c.wire), { capture: a }).catch(() => {}));
1822
+ } }), H(a, () => {
1808
1823
  i().catch(() => {});
1809
1824
  }), a;
1810
- }, In = /* @__PURE__ */ t({
1811
- box: () => Bn,
1812
- isType: () => Rn,
1813
- revive: () => Vn,
1814
- type: () => Ln
1815
- }), Ln = "blob", Rn = (e) => e instanceof Blob, zn = (e) => typeof File < "u" && e instanceof File, Bn = (e, t) => ({
1816
- ...N,
1817
- type: Ln,
1818
- mimeType: e.type,
1819
- buffer: _t(e.arrayBuffer(), t),
1820
- ...zn(e) ? {
1821
- fileName: e.name,
1822
- lastModified: e.lastModified
1823
- } : {}
1824
- }), Vn = (e, t) => vt(e.buffer, t).then((t) => e.fileName !== undefined && typeof File < "u" ? new File([t], e.fileName, {
1825
- type: e.mimeType,
1826
- lastModified: e.lastModified
1827
- }) : new Blob([t], { type: e.mimeType })), Hn = /* @__PURE__ */ t({
1828
- box: () => Gn,
1829
- isType: () => Wn,
1830
- revive: () => Kn,
1831
- type: () => Un
1832
- }), Un = "symbol", Wn = (e) => typeof e == "symbol", Gn = (e, t) => {
1825
+ }, Yn = /* @__PURE__ */ t({
1826
+ box: () => Qn,
1827
+ isType: () => Zn,
1828
+ revive: () => $n,
1829
+ type: () => Xn
1830
+ }), Xn = "symbol", Zn = (e) => typeof e == "symbol", Qn = (e, t) => {
1833
1831
  let n = Symbol.keyFor(e);
1834
- return n === undefined ? cn(e, {
1835
- ...N,
1836
- type: Un,
1832
+ return n === void 0 ? xn(e, {
1833
+ ...P,
1834
+ type: Xn,
1837
1835
  description: e.description
1838
1836
  }, t) : {
1839
- ...N,
1840
- type: Un,
1837
+ ...P,
1838
+ type: Xn,
1841
1839
  registryKey: n
1842
1840
  };
1843
- }, Kn = (e, t) => "registryKey" in e ? Symbol.for(e.registryKey) : Symbol(e.description), qn = /* @__PURE__ */ t({
1844
- box: () => Xn,
1845
- isType: () => Yn,
1846
- revive: () => Zn,
1847
- type: () => Jn
1848
- }), Jn = "asyncIterator", Yn = (e) => !e || typeof e != "object" || typeof ReadableStream < "u" && e instanceof ReadableStream ? false : typeof e[Symbol.asyncIterator] == "function", Xn = (e, t) => {
1841
+ }, $n = (e, t) => "registryKey" in e ? Symbol.for(e.registryKey) : Symbol(e.description), er = /* @__PURE__ */ t({
1842
+ box: () => rr,
1843
+ isType: () => nr,
1844
+ revive: () => ir,
1845
+ type: () => tr
1846
+ }), tr = "asyncIterator", nr = (e) => !e || typeof e != "object" || typeof ReadableStream < "u" && e instanceof ReadableStream ? !1 : typeof e[Symbol.asyncIterator] == "function", rr = (e, t) => {
1849
1847
  let n = e[Symbol.asyncIterator]();
1850
1848
  return {
1851
- ...N,
1852
- type: Jn,
1853
- next: G(((e) => n.next(e)), t),
1854
- return: G(((e) => n.return?.(e) ?? Promise.resolve({
1849
+ ...P,
1850
+ type: tr,
1851
+ next: Y(((e) => n.next(e)), t),
1852
+ return: Y(((e) => n.return?.(e) ?? Promise.resolve({
1855
1853
  done: !0,
1856
1854
  value: e
1857
1855
  })), t),
1858
- throw: G(((e) => n.throw?.(e) ?? Promise.reject(e)), t)
1856
+ throw: Y(((e) => n.throw?.(e) ?? Promise.reject(e)), t)
1859
1857
  };
1860
- }, Zn = (e, t) => {
1861
- let n = K(e.next, t), r = K(e.return, t), i = K(e.throw, t), a = {
1858
+ }, ir = (e, t) => {
1859
+ let n = X(e.next, t), r = X(e.return, t), i = X(e.throw, t), a = {
1862
1860
  next: (...e) => n(...e),
1863
1861
  return: (e) => r(e),
1864
1862
  throw: (e) => i(e),
1865
1863
  [Symbol.asyncIterator]: () => a
1866
1864
  };
1867
1865
  return a;
1868
- }, Qn = [
1866
+ }, ar = [
1869
1867
  globalThis.File,
1870
1868
  globalThis.FileList,
1871
1869
  globalThis.RegExp,
@@ -1885,7 +1883,7 @@ var ue = (e) => {
1885
1883
  globalThis.FileSystemFileHandle,
1886
1884
  globalThis.FileSystemDirectoryHandle,
1887
1885
  globalThis.RTCCertificate
1888
- ], $n = [
1886
+ ], or = [
1889
1887
  globalThis.CropTarget,
1890
1888
  globalThis.EncodedAudioChunk,
1891
1889
  globalThis.EncodedVideoChunk,
@@ -1896,64 +1894,72 @@ var ue = (e) => {
1896
1894
  globalThis.RTCEncodedAudioFrame,
1897
1895
  globalThis.RTCEncodedVideoFrame,
1898
1896
  globalThis.WebTransportError
1899
- ], er = {
1897
+ ], sr = {
1900
1898
  type: "clonable",
1901
- capableOnly: true,
1902
- isType: (e) => C(e, Qn) || C(e, $n),
1899
+ capableOnly: !0,
1900
+ isType: (e) => w(e, ar) || w(e, or),
1903
1901
  box: (e, t) => e,
1904
1902
  revive: (e, t) => e
1905
- }, tr = [
1903
+ }, cr = [
1906
1904
  globalThis.ImageBitmap,
1907
1905
  globalThis.OffscreenCanvas,
1908
1906
  globalThis.WritableStream,
1909
1907
  globalThis.TransformStream,
1910
1908
  globalThis.MediaStreamTrack,
1911
1909
  globalThis.RTCDataChannel
1912
- ], nr = [
1910
+ ], lr = [
1913
1911
  globalThis.AudioData,
1914
1912
  globalThis.VideoFrame,
1915
1913
  globalThis.MediaSourceHandle,
1916
1914
  globalThis.MIDIAccess,
1917
1915
  globalThis.WebTransportReceiveStream,
1918
1916
  globalThis.WebTransportSendStream
1919
- ], rr = {
1917
+ ], ur = {
1920
1918
  type: "transferable",
1921
- capableOnly: true,
1922
- isType: (e) => C(e, tr) || C(e, nr),
1919
+ capableOnly: !0,
1920
+ isType: (e) => w(e, cr) || w(e, lr),
1923
1921
  box: (e, t) => e,
1924
1922
  revive: (e, t) => e
1925
- }, ir = (e) => {
1926
- if (typeof e != "object" || !e) return false;
1923
+ }, dr = {
1924
+ type: "blob",
1925
+ capableOnly: !0,
1926
+ isType: (e) => typeof Blob < "u" && e instanceof Blob,
1927
+ box: (e, t) => {
1928
+ if (A(t.transport)) throw TypeError("osra: Blob is only supported on structured-clone transports, send an ArrayBuffer or Uint8Array instead");
1929
+ return e;
1930
+ },
1931
+ revive: (e, t) => e
1932
+ }, fr = (e) => {
1933
+ if (typeof e != "object" || !e) return !1;
1927
1934
  let t = Object.getPrototypeOf(e);
1928
1935
  return t === Object.prototype || t === null;
1929
- }, ar = [
1930
- We,
1931
- Yt,
1932
- ge,
1933
- xe,
1934
- Ee,
1935
- je,
1936
- Le,
1937
- In,
1938
- ft,
1939
- yt,
1940
- rt,
1941
- Ct,
1936
+ }, pr = [
1937
+ He,
1938
+ sn,
1939
+ he,
1940
+ be,
1941
+ Te,
1942
+ Ae,
1943
+ Ie,
1944
+ _t,
1945
+ wt,
1946
+ tt,
1942
1947
  Ot,
1943
- Nt,
1944
1948
  zt,
1945
1949
  Wt,
1946
- un,
1947
- mn,
1948
- vn,
1949
- Hn,
1950
+ Xt,
1951
+ tn,
1950
1952
  Cn,
1951
- qn,
1953
+ Dn,
1954
+ jn,
1955
+ Yn,
1956
+ In,
1957
+ er,
1952
1958
  {
1953
1959
  type: "nonFiniteNumber",
1954
1960
  isType: (e) => typeof e == "number" && !Number.isFinite(e),
1955
- box: (e, t) => k(t.transport) ? {
1956
- ...N,
1961
+ box: (e, t) => A(t.transport) ? {
1962
+ ...P,
1957
1963
  type: "nonFiniteNumber",
1958
1964
  value: String(e)
1959
1965
  } : e,
@@ -1961,65 +1967,66 @@ var ue = (e) => {
1961
1967
  },
1962
1968
  {
1963
1969
  type: "undefined",
1964
- isType: (e) => e === undefined,
1965
- box: (e, t) => k(t.transport) ? {
1966
- ...N,
1970
+ isType: (e) => e === void 0,
1971
+ box: (e, t) => A(t.transport) ? {
1972
+ ...P,
1967
1973
  type: "undefined"
1968
1974
  } : e,
1969
- revive: (e, t) => undefined
1975
+ revive: (e, t) => void 0
1970
1976
  },
1971
- er,
1972
- rr,
1973
- On,
1977
+ sr,
1978
+ ur,
1979
+ dr,
1980
+ Vn,
1974
1981
  {
1975
1982
  type: "unclonable",
1976
1983
  isType: (e) => {
1977
- if (typeof e != "object" || !e || Array.isArray(e) || ir(e)) return false;
1984
+ if (typeof e != "object" || !e || Array.isArray(e) || fr(e)) return !1;
1978
1985
  try {
1979
1986
  return structuredClone(e), !1;
1980
1987
  } catch {
1981
- return true;
1988
+ return !0;
1982
1989
  }
1983
1990
  },
1984
1991
  box: (e, t) => ({
1985
- ...N,
1992
+ ...P,
1986
1993
  type: "unclonable"
1987
1994
  }),
1988
1995
  revive: (e, t) => ({})
1989
1996
  }
1990
- ], or = (e, t) => t.find((t) => t.isType(e)), sr = (e, t) => t.find((t) => t.type === e.type), cr = (e) => !!e && typeof e == "object" && Object.getPrototypeOf(e) === Object.prototype, lr = (e, t) => Array.isArray(e) ? e.map((e) => t(e)) : cr(e) ? Object.fromEntries(Object.entries(e).map(([e, n]) => [e, t(n)])) : e, ur = /* @__PURE__ */ new WeakSet(), dr = /* @__PURE__ */ new WeakSet(), fr = (e) => e !== null && (typeof e == "object" || typeof e == "function"), X = (e, t) => {
1991
- if (P(e)) return e;
1992
- let n = fr(e);
1997
+ ], mr = (e, t) => t.find((t) => t.isType(e)), hr = (e, t) => t.find((t) => t.type === e.type), gr = (e) => !!e && typeof e == "object" && Object.getPrototypeOf(e) === Object.prototype, _r = (e, t) => Array.isArray(e) ? e.map((e) => t(e)) : gr(e) ? Object.fromEntries(Object.entries(e).map(([e, n]) => [e, t(n)])) : e, vr = /* @__PURE__ */ new WeakSet(), yr = /* @__PURE__ */ new WeakSet(), br = (e) => e !== null && (typeof e == "object" || typeof e == "function"), Q = (e, t) => {
1998
+ if (F(e)) return e;
1999
+ let n = br(e);
1993
2000
  if (n) {
1994
- if (ur.has(e)) throw TypeError("osra: cannot serialize a circular structure - break the cycle or send the container by reference");
1995
- ur.add(e);
2001
+ if (vr.has(e)) throw TypeError("osra: cannot serialize a circular structure - break the cycle or send the container by reference");
2002
+ vr.add(e);
1996
2003
  }
1997
2004
  try {
1998
- let n = or(e, t.revivableModules);
1999
- return n ? n.box(e, t) : lr(e, (e) => X(e, t));
2005
+ let n = mr(e, t.revivableModules);
2006
+ return n ? n.box(e, t) : _r(e, (e) => Q(e, t));
2000
2007
  } finally {
2001
- n && ur.delete(e);
2008
+ n && vr.delete(e);
2002
2009
  }
2003
- }, Z = (e, t) => {
2004
- let n = fr(e);
2010
+ }, $ = (e, t) => {
2011
+ let n = br(e);
2005
2012
  if (n) {
2006
- if (dr.has(e)) throw TypeError("osra: cannot revive a circular structure");
2007
- dr.add(e);
2013
+ if (yr.has(e)) throw TypeError("osra: cannot revive a circular structure");
2014
+ yr.add(e);
2008
2015
  }
2009
2016
  try {
2010
- if (P(e)) {
2011
- let n = sr(e, t.revivableModules);
2017
+ if (F(e)) {
2018
+ let n = hr(e, t.revivableModules);
2012
2019
  if (n) return n.revive(e, t);
2013
2020
  }
2014
- return lr(e, (e) => Z(e, t));
2021
+ return _r(e, (e) => $(e, t));
2015
2022
  } finally {
2016
- n && dr.delete(e);
2023
+ n && yr.delete(e);
2017
2024
  }
2018
- }, pr = /* @__PURE__ */ t({
2019
- init: () => hr,
2020
- startBidirectionalConnection: () => Q,
2021
- type: () => mr
2022
- }), mr = "bidirectional", Q = ({ transport: e, value: t, remoteUuid: n, eventTarget: r, send: i, revivableModules: a }) => {
2025
+ }, xr = /* @__PURE__ */ t({
2026
+ init: () => wr,
2027
+ startBidirectionalConnection: () => Cr,
2028
+ type: () => Sr
2029
+ }), Sr = "bidirectional", Cr = ({ transport: e, value: t, remoteUuid: n, eventTarget: r, send: i, revivableModules: a }) => {
2023
2030
  let o = {
2024
2031
  transport: e,
2025
2032
  remoteUuid: n,
@@ -2034,14 +2041,14 @@ var ue = (e) => {
2034
2041
  }), i({
2035
2042
  type: "init",
2036
2043
  remoteUuid: n,
2037
- data: X(t, o)
2044
+ data: Q(t, o)
2038
2045
  }), {
2039
2046
  revivableContext: o,
2040
- remoteValue: s.then((e) => Z(e, o))
2047
+ remoteValue: s.then((e) => $(e, o))
2041
2048
  };
2042
- }, hr = (e) => {
2043
- if (!(A(e.transport) && j(e.transport))) return;
2044
- if (e.protocolEventTarget.addEventListener("message", ({ detail: t }) => {
2049
+ }, wr = (e) => {
2050
+ if (!(j(e.transport) && M(e.transport))) return;
2051
+ if (e.protocolEventTarget.addEventListener("message", ({ detail: { message: t, peer: n } }) => {
2045
2052
  if (t.type === "announce") {
2046
2053
  if (!t.remoteUuid) {
2047
2054
  e.sendMessage({
@@ -2055,371 +2062,438 @@ var ue = (e) => {
2055
2062
  type: "announce",
2056
2063
  remoteUuid: t.uuid
2057
2064
  });
2058
- let n = e.createConnectionEventTarget(), r;
2065
+ let r = e.createConnectionEventTarget(), i = {
2066
+ ...n(),
2067
+ abort: () => e.abortConnection(t.uuid)
2068
+ }, a;
2059
2069
  try {
2060
- r = Q({
2070
+ let n = e.valueFor(i);
2071
+ if (e.claimPendingAbort(t.uuid)) {
2072
+ e.sendMessage({
2073
+ type: "close",
2074
+ remoteUuid: t.uuid
2075
+ });
2076
+ return;
2077
+ }
2078
+ a = Cr({
2061
2079
  transport: e.transport,
2062
- value: e.value,
2080
+ value: n,
2063
2081
  remoteUuid: t.uuid,
2064
- eventTarget: n,
2082
+ eventTarget: r,
2065
2083
  send: (t) => e.sendMessage(t),
2066
2084
  revivableModules: e.revivableModules
2067
2085
  });
2068
- } catch (t) {
2069
- e.rejectRemoteValue(t);
2086
+ } catch (n) {
2087
+ e.sendMessage({
2088
+ type: "close",
2089
+ remoteUuid: t.uuid
2090
+ }), e.rejectRemoteValue(n);
2070
2091
  return;
2071
2092
  }
2072
- let i = {
2093
+ let o = {
2073
2094
  type: "bidirectional",
2074
- eventTarget: n,
2075
- connection: r
2095
+ eventTarget: r,
2096
+ connection: a
2076
2097
  };
2077
- e.connectionContexts.set(t.uuid, i), i.connection.remoteValue.then((t) => e.resolveRemoteValue(t), (t) => e.rejectRemoteValue(t));
2098
+ e.connectionContexts.set(t.uuid, o), o.connection.remoteValue.then((t) => e.addConnection(i, t), (t) => e.rejectRemoteValue(t));
2078
2099
  return;
2079
2100
  }
2080
2101
  if (t.type === "close") {
2081
2102
  if (t.remoteUuid !== e.getUuid()) return;
2082
2103
  let n = e.connectionContexts.get(t.uuid);
2083
2104
  if (!n) return;
2084
- e.connectionContexts.delete(t.uuid), Ue(n.connection.revivableContext), e.rejectRemoteValue(/* @__PURE__ */ Error("osra: peer closed the connection"));
2105
+ e.connectionContexts.delete(t.uuid), R(n.connection.revivableContext), e.rejectRemoteValue(/* @__PURE__ */ Error("osra: peer closed the connection"));
2085
2106
  return;
2086
2107
  }
2087
2108
  if (t.remoteUuid !== e.getUuid()) return;
2088
- let n = e.connectionContexts.get(t.uuid);
2089
- n && n.eventTarget.dispatchEvent(new CustomEvent("message", { detail: t }));
2090
- }), e.presetRemoteUuid !== undefined) {
2091
- let t = e.createConnectionEventTarget(), n;
2109
+ let r = e.connectionContexts.get(t.uuid);
2110
+ r && r.eventTarget.dispatchEvent(new CustomEvent("message", { detail: t }));
2111
+ }), e.presetRemoteUuid !== void 0) {
2112
+ let t = e.presetRemoteUuid, n = e.createConnectionEventTarget(), r, i;
2092
2113
  try {
2093
- n = Q({
2114
+ i = { abort: () => e.abortConnection(t) };
2115
+ let a = e.valueFor(i);
2116
+ if (e.claimPendingAbort(t)) {
2117
+ e.sendMessage({
2118
+ type: "close",
2119
+ remoteUuid: t
2120
+ });
2121
+ return;
2122
+ }
2123
+ r = Cr({
2094
2124
  transport: e.transport,
2095
- value: e.value,
2125
+ value: a,
2096
2126
  remoteUuid: e.presetRemoteUuid,
2097
- eventTarget: t,
2127
+ eventTarget: n,
2098
2128
  send: (t) => e.sendMessage(t),
2099
2129
  revivableModules: e.revivableModules
2100
2130
  });
2101
- } catch (t) {
2102
- e.rejectRemoteValue(t);
2131
+ } catch (n) {
2132
+ e.sendMessage({
2133
+ type: "close",
2134
+ remoteUuid: t
2135
+ }), e.rejectRemoteValue(n);
2103
2136
  return;
2104
2137
  }
2105
- let r = {
2138
+ let a = {
2106
2139
  type: "bidirectional",
2107
- eventTarget: t,
2108
- connection: n
2140
+ eventTarget: n,
2141
+ connection: r
2109
2142
  };
2110
- e.connectionContexts.set(e.presetRemoteUuid, r), r.connection.remoteValue.then((t) => e.resolveRemoteValue(t), (t) => e.rejectRemoteValue(t));
2143
+ e.connectionContexts.set(e.presetRemoteUuid, a), a.connection.remoteValue.then((t) => e.addConnection(i, t), (t) => e.rejectRemoteValue(t));
2111
2144
  return;
2112
2145
  }
2113
2146
  let t = 50, n, r = () => {
2114
- e.unregisterSignal?.aborted || e.connectionContexts.size > 0 || (e.sendMessage({ type: "announce" }), n = setTimeout(r, t), t = Math.min(t * 2, 1e3));
2147
+ if (!(e.unregisterSignal?.aborted || e.connectionContexts.size > 0)) {
2148
+ try {
2149
+ e.sendMessage({ type: "announce" }, "*");
2150
+ } catch {}
2151
+ n = setTimeout(r, t), t = Math.min(t * 2, 1e3);
2152
+ }
2115
2153
  };
2116
- e.unregisterSignal?.addEventListener("abort", () => clearTimeout(n), { once: true }), r();
2117
- }, gr = () => new EventTarget(), $ = (e) => {
2118
- let t = M(e), n = t ? e.emit : e, r = t ? e.receive : e;
2154
+ e.unregisterSignal?.addEventListener("abort", () => clearTimeout(n), { once: !0 }), r();
2155
+ }, Tr = () => new EventTarget(), Er = (e) => {
2156
+ let t = N(e), n = t ? e.emit : e, r = t ? e.receive : e;
2119
2157
  return {
2120
- isJson: t && "isJson" in e && e.isJson !== undefined ? e.isJson : n !== undefined && k(n) || r !== undefined && k(r),
2121
- ...n === undefined ? {} : { emit: n },
2122
- ...r === undefined ? {} : { receive: r }
2158
+ isJson: t && "isJson" in e && e.isJson !== void 0 ? e.isJson : n !== void 0 && A(n) || r !== void 0 && A(r),
2159
+ ...n === void 0 ? {} : { emit: n },
2160
+ ...r === void 0 ? {} : { receive: r }
2161
+ };
2162
+ }, Dr = (e) => e ? e(pr) : pr, Or = 32, kr = () => {
2163
+ let e = [], t = /* @__PURE__ */ new Set(), n = !1, r = () => ({
2164
+ value: void 0,
2165
+ done: !0
2166
+ });
2167
+ return {
2168
+ push: (r) => {
2169
+ if (!n) {
2170
+ if (t.size === 0) {
2171
+ e.push(r), e.length > Or && e.shift();
2172
+ return;
2173
+ }
2174
+ for (let e of t) {
2175
+ let t = e.wake;
2176
+ if (t) {
2177
+ e.wake = void 0, t({
2178
+ value: r,
2179
+ done: !1
2180
+ });
2181
+ continue;
2182
+ }
2183
+ e.buffered.push(r);
2184
+ }
2185
+ }
2186
+ },
2187
+ close: () => {
2188
+ n = !0;
2189
+ for (let e of t) {
2190
+ let t = e.wake;
2191
+ e.wake = void 0, t?.(r());
2192
+ }
2193
+ },
2194
+ iterate: () => {
2195
+ let i = { buffered: [...e] };
2196
+ t.add(i);
2197
+ let a = !1;
2198
+ return {
2199
+ [Symbol.asyncIterator]() {
2200
+ return this;
2201
+ },
2202
+ next: () => {
2203
+ if (a) return Promise.resolve(r());
2204
+ let e = i.buffered.shift();
2205
+ return e ? Promise.resolve({
2206
+ value: e,
2207
+ done: !1
2208
+ }) : n ? Promise.resolve(r()) : new Promise((e) => {
2209
+ i.wake = e;
2210
+ });
2211
+ },
2212
+ return: () => {
2213
+ a = !0, t.delete(i);
2214
+ let e = i.wake;
2215
+ return i.wake = void 0, e?.(r()), Promise.resolve(r());
2216
+ }
2217
+ };
2218
+ }
2219
+ };
2220
+ }, Ar = (e, t, n) => {
2221
+ let r = e.then(n);
2222
+ r.catch(() => {});
2223
+ let i = () => {
2224
+ let e = t.iterate();
2225
+ return {
2226
+ [Symbol.asyncIterator]() {
2227
+ return this;
2228
+ },
2229
+ next: () => e.next().then((e) => e.done ? {
2230
+ value: void 0,
2231
+ done: !0
2232
+ } : {
2233
+ value: n(e.value),
2234
+ done: !1
2235
+ }),
2236
+ return: () => e.return?.() ?? Promise.resolve({
2237
+ value: void 0,
2238
+ done: !0
2239
+ })
2240
+ };
2123
2241
  };
2124
- }, _r = (e) => e ? e(ar) : ar, yr = [pr], br = (e, { transport: t, name: i, remoteName: a, key: o = r, origin: s = "*", unregisterSignal: c, revivableModules: d, uuid: f, remoteUuid: p }) => {
2125
- let m = $(t);
2126
- if (!(A(m) && j(m))) throw Error("osra: transport must be able to both emit and receive to establish a connection; pass a bidirectional platform transport or a custom { emit, receive } pair");
2127
- let h = _r(d), g = /* @__PURE__ */ new Map(), { promise: _, resolve: ee, reject: v } = Promise.withResolvers();
2128
- _.catch(() => {});
2129
- let y = f ?? globalThis.crypto.randomUUID(), b = (e) => {
2130
- let t = {
2242
+ return Object.assign(r, { [Symbol.asyncIterator]: i });
2243
+ }, jr = Symbol.for("osra.context"), Nr = (e) => typeof e == "object" && !!e && jr in e, Fr = [xr], Ir = (e, { transport: t, name: i, remoteName: a, key: o = r, origin: s = "*", unregisterSignal: c, revivableModules: d, uuid: f, remoteUuid: p, connection: m = ({ value: e }) => e }) => {
2244
+ let h = m, g = Er(t);
2245
+ if (!(j(g) && M(g))) {
2246
+ let e = kr();
2247
+ e.close();
2248
+ let t = Promise.reject(/* @__PURE__ */ Error("osra: transport must be able to both emit and receive to establish a connection; pass a bidirectional platform transport or a custom { emit, receive } pair"));
2249
+ return t.catch(() => {}), Ar(t, e, h);
2250
+ }
2251
+ let _ = Dr(d), v = /* @__PURE__ */ new Map(), ee = /* @__PURE__ */ new Set(), y = kr(), { promise: b, resolve: x, reject: S } = Promise.withResolvers();
2252
+ b.catch(() => {});
2253
+ let C = f ?? globalThis.crypto.randomUUID(), w = (e, t = s) => {
2254
+ let r = {
2131
2255
  [n]: o,
2132
2256
  name: i,
2133
- uuid: y,
2257
+ uuid: C,
2134
2258
  ...e
2135
2259
  };
2136
- u(m, t, s, L(t));
2137
- }, x = (e) => {
2138
- c?.aborted || b(e);
2139
- }, S = gr(), te = {
2140
- transport: m,
2141
- value: e,
2142
- revivableModules: h,
2143
- connectionContexts: g,
2144
- getUuid: () => y,
2260
+ u(g, r, t, z(r));
2261
+ }, T = (e, t) => {
2262
+ c?.aborted || w(e, t);
2263
+ }, te = Tr(), ne = {
2264
+ transport: g,
2265
+ valueFor: (t) => Nr(e) ? e[jr](t) : e,
2266
+ revivableModules: _,
2267
+ connectionContexts: v,
2268
+ getUuid: () => C,
2145
2269
  presetRemoteUuid: p,
2146
- sendMessage: x,
2147
- protocolEventTarget: S,
2148
- resolveRemoteValue: ee,
2149
- rejectRemoteValue: v,
2150
- createConnectionEventTarget: gr,
2270
+ sendMessage: T,
2271
+ protocolEventTarget: te,
2272
+ rejectRemoteValue: S,
2273
+ abortConnection: (e) => {
2274
+ let t = v.get(e);
2275
+ if (!t) {
2276
+ ee.add(e);
2277
+ return;
2278
+ }
2279
+ v.delete(e), w({
2280
+ type: "close",
2281
+ remoteUuid: e
2282
+ }), R(t.connection.revivableContext), S(/* @__PURE__ */ Error("osra: connection aborted"));
2283
+ },
2284
+ claimPendingAbort: (e) => ee.delete(e),
2285
+ addConnection: (e, t) => {
2286
+ let n = {
2287
+ value: t,
2288
+ context: e
2289
+ };
2290
+ x(n), y.push(n);
2291
+ },
2292
+ createConnectionEventTarget: Tr,
2151
2293
  unregisterSignal: c
2152
2294
  };
2153
- l({
2295
+ if (l({
2154
2296
  listener: (e, t) => {
2155
- e.uuid !== y && S.dispatchEvent(new CustomEvent("message", { detail: e }));
2297
+ e.uuid !== C && te.dispatchEvent(new CustomEvent("message", { detail: {
2298
+ message: e,
2299
+ peer: () => ({
2300
+ ...t.origin ? { origin: t.origin } : {},
2301
+ ...t.source ? { source: t.source } : {},
2302
+ ...t.port ? { port: t.port } : {},
2303
+ ...t.sender ? { sender: t.sender } : {}
2304
+ })
2305
+ } }));
2156
2306
  },
2157
- transport: m,
2307
+ transport: g,
2158
2308
  remoteName: a,
2159
2309
  key: o,
2160
2310
  origin: s,
2161
2311
  unregisterSignal: c
2162
- }), c?.addEventListener("abort", () => {
2163
- for (let [e, t] of g) b({
2312
+ }), c?.aborted) return S(c.reason), y.close(), Ar(b, y, h);
2313
+ c?.addEventListener("abort", () => {
2314
+ for (let [e, t] of v) w({
2164
2315
  type: "close",
2165
2316
  remoteUuid: e
2166
- }), Ue(t.connection.revivableContext);
2167
- g.clear(), v(c.reason);
2168
- }, { once: true });
2169
- for (let e of yr) e.init(te);
2170
- return _;
2171
- }, xr = async (e, t) => br(e, t);
2172
-
2317
+ }), R(t.connection.revivableContext);
2318
+ v.clear(), y.close(), S(c.reason);
2319
+ }, { once: !0 });
2320
+ for (let e of Fr) e.init(ne);
2321
+ return Ar(b, y, h);
2322
+ }, Lr = (e, t) => Ir(e, t);
2323
+ //#endregion
2324
+ //#region src/utils.ts
2173
2325
  function debounceImmediateAndLatest(wait, func) {
2174
- let timeoutId = null;
2175
- let lastArgs = null;
2176
- const debouncedFunction = function(...args) {
2177
- const context = this;
2178
- if (timeoutId === null) {
2179
- func.apply(context, args);
2180
- } else {
2181
- lastArgs = args;
2182
- }
2183
- clearTimeout(timeoutId);
2184
- timeoutId = setTimeout(() => {
2185
- if (lastArgs) {
2186
- func.apply(context, lastArgs);
2187
- lastArgs = null;
2188
- }
2189
- timeoutId = null;
2190
- }, wait);
2191
- };
2192
- return debouncedFunction;
2326
+ let timeoutId = null;
2327
+ let lastArgs = null;
2328
+ const debouncedFunction = function(...args) {
2329
+ const context = this;
2330
+ if (timeoutId === null) func.apply(context, args);
2331
+ else lastArgs = args;
2332
+ clearTimeout(timeoutId);
2333
+ timeoutId = setTimeout(() => {
2334
+ if (lastArgs) {
2335
+ func.apply(context, lastArgs);
2336
+ lastArgs = null;
2337
+ }
2338
+ timeoutId = null;
2339
+ }, wait);
2340
+ };
2341
+ return debouncedFunction;
2193
2342
  }
2194
- const queuedThrottleWithLastCall = (time, func) => {
2195
- let runningFunction;
2196
- let lastCall;
2197
- let lastCallArguments;
2198
- const checkForLastCall = (timeStart, resolve, reject) => (result) => {
2199
- const currentTime = performance.now();
2200
- setTimeout(() => {
2201
- if (!lastCallArguments) {
2202
- runningFunction = undefined;
2203
- lastCall = undefined;
2204
- return;
2205
- }
2206
- const funcResult = (async () => func(...lastCallArguments))();
2207
- lastCallArguments = undefined;
2208
- funcResult.then(resolve).catch((err) => {
2209
- console.error(err);
2210
- reject(err);
2211
- });
2212
- let _resolve;
2213
- let _reject;
2214
- lastCall = new Promise((resolve2, reject2) => {
2215
- _resolve = resolve2;
2216
- _reject = reject2;
2217
- });
2218
- runningFunction = funcResult.then(checkForLastCall(currentTime, _resolve, _reject)).catch((err) => {
2219
- console.error(err);
2220
- return checkForLastCall(timeStart, _resolve, _reject)(err);
2221
- });
2222
- }, time - (currentTime - timeStart));
2223
- return result;
2224
- };
2225
- return (...args) => {
2226
- lastCallArguments = args;
2227
- if (!runningFunction) {
2228
- const timeStart = performance.now();
2229
- const funcResult = (async () => func(...args))();
2230
- lastCallArguments = undefined;
2231
- let _resolve;
2232
- let _reject;
2233
- lastCall = new Promise((resolve, reject) => {
2234
- _resolve = resolve;
2235
- _reject = reject;
2236
- });
2237
- runningFunction = funcResult.then(checkForLastCall(timeStart, _resolve, _reject)).catch((err) => {
2238
- console.error(err);
2239
- return checkForLastCall(timeStart, _resolve, _reject)(err);
2240
- });
2241
- return funcResult;
2242
- } else {
2243
- return lastCall;
2244
- }
2245
- };
2343
+ var queuedThrottleWithLastCall = (time, func) => {
2344
+ let runningFunction;
2345
+ let lastCall;
2346
+ let lastCallArguments;
2347
+ const checkForLastCall = (timeStart, resolve, reject) => (result) => {
2348
+ const currentTime = performance.now();
2349
+ setTimeout(() => {
2350
+ if (!lastCallArguments) {
2351
+ runningFunction = void 0;
2352
+ lastCall = void 0;
2353
+ return;
2354
+ }
2355
+ const funcResult = (async () => func(...lastCallArguments))();
2356
+ lastCallArguments = void 0;
2357
+ funcResult.then(resolve).catch((err) => {
2358
+ console.error(err);
2359
+ reject(err);
2360
+ });
2361
+ let _resolve;
2362
+ let _reject;
2363
+ lastCall = new Promise((resolve, reject) => {
2364
+ _resolve = resolve;
2365
+ _reject = reject;
2366
+ });
2367
+ runningFunction = funcResult.then(checkForLastCall(currentTime, _resolve, _reject)).catch((err) => {
2368
+ console.error(err);
2369
+ return checkForLastCall(timeStart, _resolve, _reject)(err);
2370
+ });
2371
+ }, time - (currentTime - timeStart));
2372
+ return result;
2373
+ };
2374
+ return (...args) => {
2375
+ lastCallArguments = args;
2376
+ if (!runningFunction) {
2377
+ const timeStart = performance.now();
2378
+ const funcResult = (async () => func(...args))();
2379
+ lastCallArguments = void 0;
2380
+ let _resolve;
2381
+ let _reject;
2382
+ lastCall = new Promise((resolve, reject) => {
2383
+ _resolve = resolve;
2384
+ _reject = reject;
2385
+ });
2386
+ runningFunction = funcResult.then(checkForLastCall(timeStart, _resolve, _reject)).catch((err) => {
2387
+ console.error(err);
2388
+ return checkForLastCall(timeStart, _resolve, _reject)(err);
2389
+ });
2390
+ return funcResult;
2391
+ } else return lastCall;
2392
+ };
2246
2393
  };
2247
- const toStreamChunkSize = (SIZE) => (stream) => new ReadableStream({
2248
- reader: undefined,
2249
- leftOverData: undefined,
2250
- start() {
2251
- this.reader = stream.getReader();
2252
- },
2253
- async pull(controller) {
2254
- const { leftOverData } = this;
2255
- const accumulate = async ({ buffer: buffer2 = new Uint8Array(SIZE), currentSize = 0 } = {}) => {
2256
- const { value: newBuffer, done: done2 } = await this.reader.read();
2257
- if (currentSize === 0 && leftOverData) {
2258
- buffer2.set(leftOverData);
2259
- currentSize += leftOverData.byteLength;
2260
- this.leftOverData = undefined;
2261
- }
2262
- if (done2) {
2263
- const finalResult = { buffer: buffer2.slice(0, currentSize), currentSize, done: done2 };
2264
- this.reader = undefined;
2265
- this.leftOverData = undefined;
2266
- return finalResult;
2267
- }
2268
- let newSize;
2269
- const slicedBuffer = newBuffer.slice(0, SIZE - currentSize);
2270
- newSize = currentSize + slicedBuffer.byteLength;
2271
- buffer2.set(slicedBuffer, currentSize);
2272
- if (newSize === SIZE) {
2273
- this.leftOverData = newBuffer.slice(SIZE - currentSize);
2274
- return { buffer: buffer2, currentSize: newSize, done: false };
2275
- }
2276
- return accumulate({ buffer: buffer2, currentSize: newSize });
2277
- };
2278
- const { buffer, done } = await accumulate();
2279
- if (buffer?.byteLength) controller.enqueue(buffer);
2280
- if (done) controller.close();
2281
- },
2282
- cancel() {
2283
- this.reader?.cancel();
2284
- this.leftOverData = undefined;
2285
- }
2286
- });
2287
- const toBufferedStream = (SIZE) => (stream) => new ReadableStream({
2288
- buffers: [],
2289
- currentPullPromise: undefined,
2290
- reader: undefined,
2291
- leftOverData: undefined,
2292
- start() {
2293
- this.reader = stream.getReader();
2294
- },
2295
- async pull(controller) {
2296
- const pull = async () => {
2297
- if (this.buffers.length >= SIZE) return;
2298
- this.currentPullPromise = this.reader.read();
2299
- const { value: newBuffer, done } = await this.currentPullPromise;
2300
- this.currentPullPromise = undefined;
2301
- if (done) {
2302
- try {
2303
- for (const buffer of this.buffers) controller.enqueue(buffer);
2304
- controller.close();
2305
- } catch (err) {
2306
- }
2307
- return;
2308
- }
2309
- this.buffers.push(newBuffer);
2310
- return newBuffer;
2311
- };
2312
- const tryToBuffer = async () => {
2313
- if (this.buffers.length >= SIZE) return;
2314
- if (this.buffers.length === 0) {
2315
- const buffer = await pull();
2316
- if (!buffer) return;
2317
- return tryToBuffer();
2318
- } else {
2319
- pull().then((buffer) => {
2320
- if (!buffer) return;
2321
- tryToBuffer();
2322
- });
2323
- }
2324
- };
2325
- await tryToBuffer();
2326
- try {
2327
- controller.enqueue(this.buffers.shift());
2328
- tryToBuffer();
2329
- } catch (err) {
2330
- if (!(err instanceof TypeError && (err.message === "ReadableStreamDefaultController.enqueue: Cannot enqueue into a stream that has already been requested to close." || err.message === `Failed to execute 'enqueue' on 'ReadableStreamDefaultController': Cannot enqueue a chunk into a readable stream that is closed or has been requested to be closed`))) {
2331
- throw err;
2332
- }
2333
- }
2334
- },
2335
- cancel() {
2336
- this.reader.cancel();
2337
- }
2338
- });
2339
-
2340
- const abortSignalToPromise = (abortSignal) => new Promise((resolve, reject) => {
2341
- if (abortSignal.aborted) {
2342
- return reject();
2343
- }
2344
- abortSignal.addEventListener("abort", () => {
2345
- reject();
2346
- });
2394
+ //#endregion
2395
+ //#region src/index.ts
2396
+ var abortSignalToPromise = (abortSignal) => new Promise((resolve, reject) => {
2397
+ if (abortSignal.aborted) return reject();
2398
+ abortSignal.addEventListener("abort", () => {
2399
+ reject();
2400
+ });
2347
2401
  });
2348
- const makeRemuxer = async ({
2349
- publicPath,
2350
- workerUrl,
2351
- workerOptions,
2352
- read,
2353
- length,
2354
- bufferSize = 25e5,
2355
- audioStreamIndex
2356
- }) => {
2357
- const worker = new Worker(workerUrl, workerOptions);
2358
- const { makeRemuxer: makeRemuxer2 } = await xr({}, { transport: worker });
2359
- let reader;
2360
- const remuxer = await makeRemuxer2({
2361
- publicPath,
2362
- length,
2363
- bufferSize,
2364
- audioStreamIndex,
2365
- log: async (isError, text) => {
2366
- if (isError) console.error(text);
2367
- else console.log(text);
2368
- }
2369
- });
2370
- const queue = new PQueue({ concurrency: 1 });
2371
- const wasmRead = (abortController) => (offset, size) => {
2372
- if (abortController.signal.aborted) return Promise.resolve({ resolved: new Uint8Array(0).buffer, rejected: true });
2373
- return Promise.race([
2374
- read(Number(offset), Number(size)).then(
2375
- (buffer) => ({ resolved: new Uint8Array(buffer).buffer, rejected: false }),
2376
- () => ({ resolved: new Uint8Array(0).buffer, rejected: true })
2377
- ),
2378
- abortSignalToPromise(abortController.signal).then(
2379
- () => ({ resolved: new Uint8Array(0).buffer, rejected: true }),
2380
- () => ({ resolved: new Uint8Array(0).buffer, rejected: true })
2381
- )
2382
- ]);
2383
- };
2384
- let abortControllers = [];
2385
- const addTask = (func) => {
2386
- const currentAbortControllers = [...abortControllers];
2387
- abortControllers = [];
2388
- queue.clear();
2389
- currentAbortControllers.forEach((abortController2) => abortController2.abort());
2390
- const abortController = new AbortController();
2391
- abortControllers = [...abortControllers, abortController];
2392
- return Promise.race([
2393
- queue.add(
2394
- async () => func(abortController),
2395
- { signal: abortController.signal }
2396
- ),
2397
- abortSignalToPromise(abortController.signal).then(
2398
- () => Promise.reject(new Error("Cancelled")),
2399
- () => Promise.reject(new Error("Cancelled"))
2400
- )
2401
- ]);
2402
- };
2403
- return {
2404
- worker,
2405
- init: () => addTask((abortController) => remuxer.init(wasmRead(abortController))),
2406
- destroy: async () => {
2407
- try {
2408
- await reader?.cancel();
2409
- } catch (err) {
2410
- }
2411
- reader = undefined;
2412
- const currentAbortControllers = [...abortControllers];
2413
- abortControllers = [];
2414
- queue.clear();
2415
- currentAbortControllers.forEach((abortController) => abortController.abort());
2416
- await remuxer.destroy();
2417
- worker.terminate();
2418
- },
2419
- seek: (timestamp) => addTask((abortController) => remuxer.seek(wasmRead(abortController), timestamp)),
2420
- read: () => addTask((abortController) => remuxer.read(wasmRead(abortController))),
2421
- readKeyframe: (timestamp) => addTask((abortController) => remuxer.readKeyframe(wasmRead(abortController), timestamp))
2422
- };
2402
+ /**
2403
+ * The worker, the wasm instance and the serialized task queue that both public entry points share.
2404
+ *
2405
+ * Split out because a thumbnailer and a remuxer need identical plumbing and nothing else in common: only
2406
+ * which wasm entry point they open the file with, and which calls they then expose.
2407
+ */
2408
+ var makeSession = async ({ publicPath, workerUrl, workerOptions, read, length, bufferSize, audioStreamIndex }) => {
2409
+ const worker = new Worker(workerUrl, workerOptions);
2410
+ const { makeRemuxer } = await Lr({}, { transport: worker });
2411
+ const remuxer = await makeRemuxer({
2412
+ publicPath,
2413
+ length,
2414
+ bufferSize,
2415
+ audioStreamIndex
2416
+ });
2417
+ const queue = new PQueue({ concurrency: 1 });
2418
+ const wasmRead = (abortController) => (offset, size) => {
2419
+ if (abortController.signal.aborted) return Promise.resolve({
2420
+ resolved: (/* @__PURE__ */ new Uint8Array(0)).buffer,
2421
+ rejected: true
2422
+ });
2423
+ return Promise.race([read(Number(offset), Number(size)).then((buffer) => ({
2424
+ resolved: new Uint8Array(buffer).buffer,
2425
+ rejected: false
2426
+ }), () => ({
2427
+ resolved: (/* @__PURE__ */ new Uint8Array(0)).buffer,
2428
+ rejected: true
2429
+ })), abortSignalToPromise(abortController.signal).then(() => ({
2430
+ resolved: (/* @__PURE__ */ new Uint8Array(0)).buffer,
2431
+ rejected: true
2432
+ }), () => ({
2433
+ resolved: (/* @__PURE__ */ new Uint8Array(0)).buffer,
2434
+ rejected: true
2435
+ }))]);
2436
+ };
2437
+ let abortControllers = [];
2438
+ const addTask = (func) => {
2439
+ const currentAbortControllers = [...abortControllers];
2440
+ abortControllers = [];
2441
+ queue.clear();
2442
+ currentAbortControllers.forEach((abortController) => abortController.abort());
2443
+ const abortController = new AbortController();
2444
+ abortControllers = [...abortControllers, abortController];
2445
+ return Promise.race([queue.add(async () => func(abortController), { signal: abortController.signal }), abortSignalToPromise(abortController.signal).then(() => Promise.reject(/* @__PURE__ */ new Error("Cancelled")), () => Promise.reject(/* @__PURE__ */ new Error("Cancelled")))]);
2446
+ };
2447
+ const destroy = async () => {
2448
+ const currentAbortControllers = [...abortControllers];
2449
+ abortControllers = [];
2450
+ queue.clear();
2451
+ currentAbortControllers.forEach((abortController) => abortController.abort());
2452
+ await remuxer.destroy();
2453
+ worker.terminate();
2454
+ };
2455
+ return {
2456
+ worker,
2457
+ remuxer,
2458
+ wasmRead,
2459
+ addTask,
2460
+ destroy
2461
+ };
2462
+ };
2463
+ var makeRemuxer = async (options) => {
2464
+ const { worker, remuxer, wasmRead, addTask, destroy } = await makeSession({
2465
+ ...options,
2466
+ bufferSize: options.bufferSize ?? 25e5
2467
+ });
2468
+ return {
2469
+ worker,
2470
+ init: () => addTask((abortController) => remuxer.init(wasmRead(abortController))),
2471
+ destroy,
2472
+ seek: (timestamp) => addTask((abortController) => remuxer.seek(wasmRead(abortController), timestamp)),
2473
+ read: () => addTask((abortController) => remuxer.read(wasmRead(abortController))),
2474
+ readKeyframe: (timestamp) => addTask((abortController) => remuxer.readKeyframe(wasmRead(abortController), timestamp)),
2475
+ /** Takes effect on the next seek */
2476
+ setAudioStreamIndex: (index) => remuxer.setAudioStreamIndex(index)
2477
+ };
2478
+ };
2479
+ /**
2480
+ * Open a file for thumbnails only. No output muxer, no encoder, no stream map, no header.
2481
+ *
2482
+ * `readKeyframe` seeks BACKWARD on the input, which an output muxer cannot follow, so a remuxer that also
2483
+ * served thumbnails could only be kept correct by never doing both on one instance. There is no muxer here
2484
+ * to damage. It also opens files whose audio the muxer refuses outright, which a remuxer cannot.
2485
+ */
2486
+ var makeThumbnailer = async (options) => {
2487
+ const { worker, remuxer, wasmRead, addTask, destroy } = await makeSession({
2488
+ ...options,
2489
+ bufferSize: options.bufferSize ?? 1e6
2490
+ });
2491
+ return {
2492
+ worker,
2493
+ init: () => addTask((abortController) => remuxer.initThumbnail(wasmRead(abortController))),
2494
+ readKeyframe: (timestamp) => addTask((abortController) => remuxer.readKeyframe(wasmRead(abortController), timestamp)),
2495
+ destroy
2496
+ };
2423
2497
  };
2424
-
2425
- export { debounceImmediateAndLatest, makeRemuxer, queuedThrottleWithLastCall, toBufferedStream, toStreamChunkSize };
2498
+ //#endregion
2499
+ export { debounceImmediateAndLatest, makeRemuxer, makeThumbnailer, queuedThrottleWithLastCall };