capnweb 0.0.0-32e381c → 0.0.0-3447dde
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/README.md +33 -33
- package/dist/index-bun.cjs +265 -104
- package/dist/index-bun.cjs.map +1 -1
- package/dist/index-bun.d.cts +55 -32
- package/dist/index-bun.d.ts +55 -32
- package/dist/index-bun.js +265 -103
- package/dist/index-bun.js.map +1 -1
- package/dist/index-workers.cjs +266 -104
- package/dist/index-workers.cjs.map +1 -1
- package/dist/index-workers.d.cts +51 -31
- package/dist/index-workers.d.ts +51 -31
- package/dist/index-workers.js +265 -103
- package/dist/index-workers.js.map +1 -1
- package/dist/index.cjs +265 -104
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +51 -31
- package/dist/index.d.ts +51 -31
- package/dist/index.js +265 -103
- package/dist/index.js.map +1 -1
- package/package.json +21 -26
package/dist/index-bun.cjs
CHANGED
|
@@ -1,5 +1,4 @@
|
|
|
1
1
|
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
|
2
|
-
|
|
3
2
|
//#region src/symbols.ts
|
|
4
3
|
let WORKERS_MODULE_SYMBOL = Symbol("workers-module");
|
|
5
4
|
|
|
@@ -42,6 +41,9 @@ function typeForRpc(value) {
|
|
|
42
41
|
case AsyncFunction.prototype: return "function";
|
|
43
42
|
case Array.prototype: return "array";
|
|
44
43
|
case Date.prototype: return "date";
|
|
44
|
+
case RegExp.prototype: return "regexp";
|
|
45
|
+
case Set.prototype: return "set";
|
|
46
|
+
case Map.prototype: return "map";
|
|
45
47
|
case Uint8Array.prototype:
|
|
46
48
|
case BUFFER_PROTOTYPE:
|
|
47
49
|
case ArrayBuffer.prototype:
|
|
@@ -305,6 +307,9 @@ async function pullPromise(promise) {
|
|
|
305
307
|
if (pathIfPromise.length > 0) hook = hook.get(pathIfPromise);
|
|
306
308
|
return (await hook.pull()).deliverResolve();
|
|
307
309
|
}
|
|
310
|
+
function mapKeyToPropertyName(key) {
|
|
311
|
+
return typeof key === "string" || typeof key === "number" ? key : { mapKey: key };
|
|
312
|
+
}
|
|
308
313
|
var RpcPayload = class RpcPayload {
|
|
309
314
|
value;
|
|
310
315
|
source;
|
|
@@ -359,12 +364,13 @@ var RpcPayload = class RpcPayload {
|
|
|
359
364
|
return TargetStubHook.create(target, parent);
|
|
360
365
|
} else if (this.source === "return") {
|
|
361
366
|
let hook = this.rpcTargets?.get(target);
|
|
362
|
-
if (hook)
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
367
|
+
if (hook) {
|
|
368
|
+
if (dupStubs) return hook.dup();
|
|
369
|
+
else {
|
|
370
|
+
this.rpcTargets?.delete(target);
|
|
371
|
+
return hook;
|
|
372
|
+
}
|
|
373
|
+
} else {
|
|
368
374
|
hook = TargetStubHook.create(target, parent);
|
|
369
375
|
if (dupStubs) {
|
|
370
376
|
if (!this.rpcTargets) this.rpcTargets = /* @__PURE__ */ new Map();
|
|
@@ -378,12 +384,13 @@ var RpcPayload = class RpcPayload {
|
|
|
378
384
|
if (this.source === "params") return streamImpl.createWritableStreamHook(stream);
|
|
379
385
|
else if (this.source === "return") {
|
|
380
386
|
let hook = this.rpcTargets?.get(stream);
|
|
381
|
-
if (hook)
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
+
if (hook) {
|
|
388
|
+
if (dupStubs) return hook.dup();
|
|
389
|
+
else {
|
|
390
|
+
this.rpcTargets?.delete(stream);
|
|
391
|
+
return hook;
|
|
392
|
+
}
|
|
393
|
+
} else {
|
|
387
394
|
hook = streamImpl.createWritableStreamHook(stream);
|
|
388
395
|
if (dupStubs) {
|
|
389
396
|
if (!this.rpcTargets) this.rpcTargets = /* @__PURE__ */ new Map();
|
|
@@ -397,12 +404,13 @@ var RpcPayload = class RpcPayload {
|
|
|
397
404
|
if (this.source === "params") return streamImpl.createReadableStreamHook(stream);
|
|
398
405
|
else if (this.source === "return") {
|
|
399
406
|
let hook = this.rpcTargets?.get(stream);
|
|
400
|
-
if (hook)
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
407
|
+
if (hook) {
|
|
408
|
+
if (dupStubs) return hook.dup();
|
|
409
|
+
else {
|
|
410
|
+
this.rpcTargets?.delete(stream);
|
|
411
|
+
return hook;
|
|
412
|
+
}
|
|
413
|
+
} else {
|
|
406
414
|
hook = streamImpl.createReadableStreamHook(stream);
|
|
407
415
|
if (dupStubs) {
|
|
408
416
|
if (!this.rpcTargets) this.rpcTargets = /* @__PURE__ */ new Map();
|
|
@@ -421,6 +429,7 @@ var RpcPayload = class RpcPayload {
|
|
|
421
429
|
case "bytes":
|
|
422
430
|
case "blob":
|
|
423
431
|
case "url":
|
|
432
|
+
case "regexp":
|
|
424
433
|
case "error":
|
|
425
434
|
case "undefined": return value;
|
|
426
435
|
case "array": {
|
|
@@ -430,6 +439,35 @@ var RpcPayload = class RpcPayload {
|
|
|
430
439
|
for (let i = 0; i < len; i++) result[i] = this.deepCopy(array[i], array, i, result, dupStubs, owner);
|
|
431
440
|
return result;
|
|
432
441
|
}
|
|
442
|
+
case "set": {
|
|
443
|
+
let set = value;
|
|
444
|
+
let elements = [...set];
|
|
445
|
+
for (let val of elements) {
|
|
446
|
+
let kind = typeForRpc(val);
|
|
447
|
+
if (kind === "rpc-promise" || kind === "rpc-thenable") throw new TypeError("Cannot pass a promise as an element of a Set. Await the value before adding it to the Set.");
|
|
448
|
+
}
|
|
449
|
+
let result = /* @__PURE__ */ new Set();
|
|
450
|
+
let index = 0;
|
|
451
|
+
for (let val of elements) {
|
|
452
|
+
let copy = this.deepCopy(val, set, index++, result, dupStubs, owner);
|
|
453
|
+
result.add(copy);
|
|
454
|
+
}
|
|
455
|
+
return result;
|
|
456
|
+
}
|
|
457
|
+
case "map": {
|
|
458
|
+
let map = value;
|
|
459
|
+
let entries = [...map];
|
|
460
|
+
for (let [key] of entries) {
|
|
461
|
+
let kind = typeForRpc(key);
|
|
462
|
+
if (kind === "rpc-promise" || kind === "rpc-thenable") throw new TypeError("Cannot pass a promise as a key of a Map. Await the value before using it as a key.");
|
|
463
|
+
}
|
|
464
|
+
let result = /* @__PURE__ */ new Map();
|
|
465
|
+
for (let [key, val] of entries) {
|
|
466
|
+
let keyCopy = this.deepCopy(key, map, -1, result, dupStubs, owner);
|
|
467
|
+
result.set(keyCopy, this.deepCopy(val, map, mapKeyToPropertyName(keyCopy), result, dupStubs, owner));
|
|
468
|
+
}
|
|
469
|
+
return result;
|
|
470
|
+
}
|
|
433
471
|
case "object": {
|
|
434
472
|
let result = {};
|
|
435
473
|
let object = value;
|
|
@@ -514,6 +552,10 @@ var RpcPayload = class RpcPayload {
|
|
|
514
552
|
try {
|
|
515
553
|
this.value = this.deepCopy(this.value, void 0, "value", this, dupStubs, this);
|
|
516
554
|
} catch (err) {
|
|
555
|
+
if (dupStubs) {
|
|
556
|
+
this.hooks.forEach((hook) => hook.dispose());
|
|
557
|
+
this.promises.forEach((promise) => promise.promise[Symbol.dispose]());
|
|
558
|
+
}
|
|
517
559
|
this.hooks = void 0;
|
|
518
560
|
this.promises = void 0;
|
|
519
561
|
throw err;
|
|
@@ -527,7 +569,8 @@ var RpcPayload = class RpcPayload {
|
|
|
527
569
|
this.ensureDeepCopied();
|
|
528
570
|
if (this.value instanceof RpcPromise$1) RpcPayload.deliverRpcPromiseTo(this.value, parent, property, promises);
|
|
529
571
|
else {
|
|
530
|
-
parent
|
|
572
|
+
if (parent instanceof Map) parent.set(typeof property === "object" ? property.mapKey : property, this.value);
|
|
573
|
+
else parent[property] = this.value;
|
|
531
574
|
for (let record of this.promises) RpcPayload.deliverRpcPromiseTo(record.promise, record.parent, record.property, promises);
|
|
532
575
|
}
|
|
533
576
|
}
|
|
@@ -619,6 +662,7 @@ var RpcPayload = class RpcPayload {
|
|
|
619
662
|
case "blob":
|
|
620
663
|
case "date":
|
|
621
664
|
case "url":
|
|
665
|
+
case "regexp":
|
|
622
666
|
case "error":
|
|
623
667
|
case "undefined": return;
|
|
624
668
|
case "array": {
|
|
@@ -627,6 +671,19 @@ var RpcPayload = class RpcPayload {
|
|
|
627
671
|
for (let i = 0; i < len; i++) this.disposeImpl(array[i], array);
|
|
628
672
|
return;
|
|
629
673
|
}
|
|
674
|
+
case "set": {
|
|
675
|
+
let set = value;
|
|
676
|
+
for (let element of set) this.disposeImpl(element, set);
|
|
677
|
+
return;
|
|
678
|
+
}
|
|
679
|
+
case "map": {
|
|
680
|
+
let map = value;
|
|
681
|
+
for (let [key, val] of map) {
|
|
682
|
+
this.disposeImpl(key, map);
|
|
683
|
+
this.disposeImpl(val, map);
|
|
684
|
+
}
|
|
685
|
+
return;
|
|
686
|
+
}
|
|
630
687
|
case "object": {
|
|
631
688
|
let object = value;
|
|
632
689
|
for (let i in object) this.disposeImpl(object[i], object);
|
|
@@ -702,6 +759,7 @@ var RpcPayload = class RpcPayload {
|
|
|
702
759
|
case "writable":
|
|
703
760
|
case "readable":
|
|
704
761
|
case "url":
|
|
762
|
+
case "regexp":
|
|
705
763
|
case "headers":
|
|
706
764
|
case "request":
|
|
707
765
|
case "response": return;
|
|
@@ -711,6 +769,19 @@ var RpcPayload = class RpcPayload {
|
|
|
711
769
|
for (let i = 0; i < len; i++) this.ignoreUnhandledRejectionsImpl(array[i]);
|
|
712
770
|
return;
|
|
713
771
|
}
|
|
772
|
+
case "set": {
|
|
773
|
+
let set = value;
|
|
774
|
+
for (let element of set) this.ignoreUnhandledRejectionsImpl(element);
|
|
775
|
+
return;
|
|
776
|
+
}
|
|
777
|
+
case "map": {
|
|
778
|
+
let map = value;
|
|
779
|
+
for (let [key, val] of map) {
|
|
780
|
+
this.ignoreUnhandledRejectionsImpl(key);
|
|
781
|
+
this.ignoreUnhandledRejectionsImpl(val);
|
|
782
|
+
}
|
|
783
|
+
return;
|
|
784
|
+
}
|
|
714
785
|
case "object": {
|
|
715
786
|
let object = value;
|
|
716
787
|
for (let i in object) this.ignoreUnhandledRejectionsImpl(object[i]);
|
|
@@ -770,8 +841,11 @@ function followPath(value, parent, path, owner) {
|
|
|
770
841
|
case "bytes":
|
|
771
842
|
case "blob":
|
|
772
843
|
case "date":
|
|
844
|
+
case "set":
|
|
845
|
+
case "map":
|
|
773
846
|
case "error":
|
|
774
847
|
case "url":
|
|
848
|
+
case "regexp":
|
|
775
849
|
case "headers":
|
|
776
850
|
case "request":
|
|
777
851
|
case "response":
|
|
@@ -817,7 +891,8 @@ var ValueStubHook = class extends StubHook {
|
|
|
817
891
|
args.dispose();
|
|
818
892
|
return new ErrorStubHook(/* @__PURE__ */ new TypeError(`'${path.join(".")}' is not a function.`));
|
|
819
893
|
}
|
|
820
|
-
|
|
894
|
+
let promise = args.deliverCall(followResult.value, followResult.parent);
|
|
895
|
+
return new PromiseStubHook(promise.then((payload) => {
|
|
821
896
|
return new PayloadStubHook(payload);
|
|
822
897
|
}));
|
|
823
898
|
}
|
|
@@ -1015,7 +1090,7 @@ const DEFAULT_MAX_DEPTH = 256;
|
|
|
1015
1090
|
const DEFAULT_LIMITS = {
|
|
1016
1091
|
maxBigIntDigits: 16384,
|
|
1017
1092
|
maxDepth: 256,
|
|
1018
|
-
maxMessageSize:
|
|
1093
|
+
maxMessageSize: 33554432
|
|
1019
1094
|
};
|
|
1020
1095
|
const NATIVE_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
|
|
1021
1096
|
const BYTE_CONTAINER_TYPE_NAMES = [
|
|
@@ -1077,9 +1152,7 @@ function swapByteOrder(bytes, elementSize) {
|
|
|
1077
1152
|
case 4:
|
|
1078
1153
|
view.setUint32(offset, view.getUint32(offset, false), true);
|
|
1079
1154
|
break;
|
|
1080
|
-
case 8:
|
|
1081
|
-
view.setBigUint64(offset, view.getBigUint64(offset, false), true);
|
|
1082
|
-
break;
|
|
1155
|
+
case 8: view.setBigUint64(offset, view.getBigUint64(offset, false), true);
|
|
1083
1156
|
}
|
|
1084
1157
|
}
|
|
1085
1158
|
var NullExporter = class {
|
|
@@ -1164,6 +1237,30 @@ var Devaluator = class Devaluator {
|
|
|
1164
1237
|
for (let i = 0; i < len; i++) result[i] = this.devaluateImpl(array[i], array, depth + 1);
|
|
1165
1238
|
return [result];
|
|
1166
1239
|
}
|
|
1240
|
+
case "set": {
|
|
1241
|
+
let set = value;
|
|
1242
|
+
let setElements = [...set];
|
|
1243
|
+
let elements = [];
|
|
1244
|
+
for (let element of setElements) switch (typeForRpc(element)) {
|
|
1245
|
+
case "blob": throw new TypeError("Cannot serialize a Blob as an element of a Set.");
|
|
1246
|
+
case "rpc-promise":
|
|
1247
|
+
case "rpc-thenable": throw new TypeError("Cannot serialize a promise as an element of a Set. Await the value before adding it to the Set.");
|
|
1248
|
+
}
|
|
1249
|
+
for (let element of setElements) elements.push(this.devaluateImpl(element, set, depth + 1));
|
|
1250
|
+
return ["set", elements];
|
|
1251
|
+
}
|
|
1252
|
+
case "map": {
|
|
1253
|
+
let map = value;
|
|
1254
|
+
let mapEntries = [...map];
|
|
1255
|
+
let entries = [];
|
|
1256
|
+
for (let [key] of mapEntries) switch (typeForRpc(key)) {
|
|
1257
|
+
case "blob": throw new TypeError("Cannot serialize a Blob as a key of a Map.");
|
|
1258
|
+
case "rpc-promise":
|
|
1259
|
+
case "rpc-thenable": throw new TypeError("Cannot serialize a promise as a key of a Map. Await the value before using it as a key.");
|
|
1260
|
+
}
|
|
1261
|
+
for (let [key, val] of mapEntries) entries.push([this.devaluateImpl(key, map, depth + 1), this.devaluateImpl(val, map, depth + 1)]);
|
|
1262
|
+
return ["map", entries];
|
|
1263
|
+
}
|
|
1167
1264
|
case "bigint":
|
|
1168
1265
|
if (this.encodingLevel === "structuredClonable") return value;
|
|
1169
1266
|
return ["bigint", value.toString()];
|
|
@@ -1172,6 +1269,15 @@ var Devaluator = class Devaluator {
|
|
|
1172
1269
|
const time = value.getTime();
|
|
1173
1270
|
return ["date", Number.isNaN(time) ? null : time];
|
|
1174
1271
|
}
|
|
1272
|
+
case "regexp": {
|
|
1273
|
+
if (this.encodingLevel === "structuredClonable") return value;
|
|
1274
|
+
let re = value;
|
|
1275
|
+
return re.flags ? [
|
|
1276
|
+
"regexp",
|
|
1277
|
+
re.source,
|
|
1278
|
+
re.flags
|
|
1279
|
+
] : ["regexp", re.source];
|
|
1280
|
+
}
|
|
1175
1281
|
case "bytes": {
|
|
1176
1282
|
let alternateTypeName = BYTE_CONTAINER_TYPE_BY_PROTOTYPE.get(Object.getPrototypeOf(value));
|
|
1177
1283
|
let bytes;
|
|
@@ -1186,11 +1292,14 @@ var Devaluator = class Devaluator {
|
|
|
1186
1292
|
swapByteOrder(bytes, elementSize);
|
|
1187
1293
|
}
|
|
1188
1294
|
}
|
|
1189
|
-
if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes")
|
|
1190
|
-
|
|
1191
|
-
bytes,
|
|
1192
|
-
|
|
1193
|
-
|
|
1295
|
+
if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") {
|
|
1296
|
+
if (bytes.byteLength !== bytes.buffer.byteLength) bytes = new Uint8Array(bytes);
|
|
1297
|
+
return alternateTypeName === void 0 ? ["bytes", bytes] : [
|
|
1298
|
+
"bytes",
|
|
1299
|
+
bytes,
|
|
1300
|
+
alternateTypeName
|
|
1301
|
+
];
|
|
1302
|
+
}
|
|
1194
1303
|
let b64;
|
|
1195
1304
|
if (bytes.toBase64) b64 = bytes.toBase64({ omitPadding: true });
|
|
1196
1305
|
else if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
|
|
@@ -1329,13 +1438,16 @@ var Devaluator = class Devaluator {
|
|
|
1329
1438
|
if (!this.source) throw new Error("Can't serialize RPC stubs in this context.");
|
|
1330
1439
|
let { hook, pathIfPromise } = unwrapStubAndPath(value);
|
|
1331
1440
|
let importId = this.exporter.getImport(hook);
|
|
1332
|
-
if (importId !== void 0)
|
|
1333
|
-
|
|
1334
|
-
|
|
1335
|
-
|
|
1336
|
-
|
|
1337
|
-
|
|
1338
|
-
|
|
1441
|
+
if (importId !== void 0) {
|
|
1442
|
+
if (pathIfPromise) {
|
|
1443
|
+
if (pathIfPromise.length > 0) return [
|
|
1444
|
+
"pipeline",
|
|
1445
|
+
importId,
|
|
1446
|
+
pathIfPromise
|
|
1447
|
+
];
|
|
1448
|
+
else return ["pipeline", importId];
|
|
1449
|
+
} else return ["import", importId];
|
|
1450
|
+
}
|
|
1339
1451
|
if (pathIfPromise) hook = hook.get(pathIfPromise);
|
|
1340
1452
|
else hook = hook.dup();
|
|
1341
1453
|
return this.devaluateHook(pathIfPromise ? "promise" : "export", hook);
|
|
@@ -1396,16 +1508,18 @@ var NullImporter = class {
|
|
|
1396
1508
|
};
|
|
1397
1509
|
const NULL_IMPORTER = new NullImporter();
|
|
1398
1510
|
function fixBrokenRequestBody(request, body) {
|
|
1399
|
-
|
|
1511
|
+
let promise = new Response(body).arrayBuffer().then((arrayBuffer) => {
|
|
1400
1512
|
let bytes = new Uint8Array(arrayBuffer);
|
|
1401
1513
|
let result = new Request(request, { body: bytes });
|
|
1402
1514
|
return new PayloadStubHook(RpcPayload.fromAppReturn(result));
|
|
1403
|
-
})
|
|
1515
|
+
});
|
|
1516
|
+
return new RpcPromise$1(new PromiseStubHook(promise), []);
|
|
1404
1517
|
}
|
|
1405
1518
|
function streamToBlobPromise(stream, type) {
|
|
1406
|
-
|
|
1519
|
+
let promise = streamToBlob(stream, type).then((blob) => {
|
|
1407
1520
|
return new PayloadStubHook(RpcPayload.fromAppReturn(blob));
|
|
1408
|
-
})
|
|
1521
|
+
});
|
|
1522
|
+
return new RpcPromise$1(new PromiseStubHook(promise), []);
|
|
1409
1523
|
}
|
|
1410
1524
|
var Evaluator = class Evaluator {
|
|
1411
1525
|
importer;
|
|
@@ -1438,7 +1552,7 @@ var Evaluator = class Evaluator {
|
|
|
1438
1552
|
let maxDepth = this.limits.maxDepth;
|
|
1439
1553
|
if (depth >= maxDepth) throw new TypeError(`Deserialization exceeded maximum allowed message depth of ${maxDepth}.`);
|
|
1440
1554
|
if (this.encodingLevel === "structuredClonable") {
|
|
1441
|
-
if (value instanceof Date || typeof value === "bigint") return value;
|
|
1555
|
+
if (value instanceof Date || value instanceof RegExp || typeof value === "bigint") return value;
|
|
1442
1556
|
}
|
|
1443
1557
|
if (value instanceof Array) {
|
|
1444
1558
|
if (value.length == 1 && value[0] instanceof Array) {
|
|
@@ -1458,18 +1572,48 @@ var Evaluator = class Evaluator {
|
|
|
1458
1572
|
if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
|
|
1459
1573
|
if (typeof value[1] == "number") return new Date(value[1]);
|
|
1460
1574
|
break;
|
|
1575
|
+
case "regexp":
|
|
1576
|
+
if (typeof value[1] === "string" && (value.length === 2 || value.length === 3 && typeof value[2] === "string")) return new RegExp(value[1], value[2]);
|
|
1577
|
+
break;
|
|
1578
|
+
case "set":
|
|
1579
|
+
if (value.length === 2 && value[1] instanceof Array) {
|
|
1580
|
+
let elements = value[1];
|
|
1581
|
+
let set = /* @__PURE__ */ new Set();
|
|
1582
|
+
for (let i = 0; i < elements.length; i++) {
|
|
1583
|
+
let copy = this.evaluateImpl(elements[i], set, i, depth + 1);
|
|
1584
|
+
if (copy instanceof RpcPromise$1) throw new TypeError("Cannot deserialize a promise as an element of a Set.");
|
|
1585
|
+
set.add(copy);
|
|
1586
|
+
}
|
|
1587
|
+
return set;
|
|
1588
|
+
}
|
|
1589
|
+
break;
|
|
1590
|
+
case "map":
|
|
1591
|
+
if (value.length === 2 && value[1] instanceof Array) {
|
|
1592
|
+
let entries = value[1];
|
|
1593
|
+
let map = /* @__PURE__ */ new Map();
|
|
1594
|
+
for (let i = 0; i < entries.length; i++) {
|
|
1595
|
+
let entry = entries[i];
|
|
1596
|
+
if (!(entry instanceof Array) || entry.length !== 2) throw new TypeError("Map entries must be serialized as key/value pairs.");
|
|
1597
|
+
let key = this.evaluateImpl(entry[0], map, i, depth + 1);
|
|
1598
|
+
if (key instanceof RpcPromise$1) throw new TypeError("Cannot deserialize a promise as a key of a Map.");
|
|
1599
|
+
map.set(key, this.evaluateImpl(entry[1], map, mapKeyToPropertyName(key), depth + 1));
|
|
1600
|
+
}
|
|
1601
|
+
return map;
|
|
1602
|
+
}
|
|
1603
|
+
break;
|
|
1461
1604
|
case "bytes": {
|
|
1462
1605
|
let bytes;
|
|
1463
1606
|
if (value[1] instanceof Uint8Array) bytes = value[1];
|
|
1464
|
-
else if (typeof value[1] == "string")
|
|
1465
|
-
|
|
1466
|
-
|
|
1467
|
-
|
|
1468
|
-
|
|
1469
|
-
|
|
1470
|
-
|
|
1471
|
-
|
|
1472
|
-
|
|
1607
|
+
else if (typeof value[1] == "string") {
|
|
1608
|
+
if (typeof Buffer !== "undefined") bytes = Buffer.from(value[1], "base64");
|
|
1609
|
+
else if (Uint8Array.fromBase64) bytes = Uint8Array.fromBase64(value[1]);
|
|
1610
|
+
else {
|
|
1611
|
+
let bs = atob(value[1]);
|
|
1612
|
+
let len = bs.length;
|
|
1613
|
+
bytes = new Uint8Array(len);
|
|
1614
|
+
for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
|
|
1615
|
+
}
|
|
1616
|
+
} else break;
|
|
1473
1617
|
if (value.length === 2) return bytes;
|
|
1474
1618
|
if (typeof value[2] !== "string") throw new TypeError(`Unknown bytes type marker type: ${typeof value[2]}`);
|
|
1475
1619
|
if (!isValidByteContainerName(value[2])) {
|
|
@@ -1495,7 +1639,6 @@ var Evaluator = class Evaluator {
|
|
|
1495
1639
|
case "BigUint64Array": return new BigUint64Array(buffer);
|
|
1496
1640
|
case "Float32Array": return new Float32Array(buffer);
|
|
1497
1641
|
case "Float64Array": return new Float64Array(buffer);
|
|
1498
|
-
default:
|
|
1499
1642
|
}
|
|
1500
1643
|
}
|
|
1501
1644
|
case "error":
|
|
@@ -1598,11 +1741,13 @@ var Evaluator = class Evaluator {
|
|
|
1598
1741
|
return promise;
|
|
1599
1742
|
} else {
|
|
1600
1743
|
this.hooks.push(hook);
|
|
1601
|
-
return new
|
|
1744
|
+
return new RpcStub$1(hook);
|
|
1602
1745
|
}
|
|
1603
1746
|
};
|
|
1604
|
-
if (value.length == 2)
|
|
1605
|
-
|
|
1747
|
+
if (value.length == 2) {
|
|
1748
|
+
if (isPromise) return addStub(hook.get([]));
|
|
1749
|
+
else return addStub(hook.dup());
|
|
1750
|
+
}
|
|
1606
1751
|
let path = value[2];
|
|
1607
1752
|
if (!(path instanceof Array)) break;
|
|
1608
1753
|
if (!path.every((part) => {
|
|
@@ -1632,7 +1777,8 @@ var Evaluator = class Evaluator {
|
|
|
1632
1777
|
}
|
|
1633
1778
|
});
|
|
1634
1779
|
let instructions = value[4];
|
|
1635
|
-
let
|
|
1780
|
+
let resultHook = hook.map(path, captures, instructions);
|
|
1781
|
+
let promise = new RpcPromise$1(resultHook, []);
|
|
1636
1782
|
this.promises.push({
|
|
1637
1783
|
promise,
|
|
1638
1784
|
parent,
|
|
@@ -1642,18 +1788,21 @@ var Evaluator = class Evaluator {
|
|
|
1642
1788
|
}
|
|
1643
1789
|
case "export":
|
|
1644
1790
|
case "promise":
|
|
1645
|
-
if (typeof value[1] == "number")
|
|
1646
|
-
|
|
1647
|
-
|
|
1648
|
-
|
|
1649
|
-
|
|
1650
|
-
|
|
1651
|
-
|
|
1652
|
-
|
|
1653
|
-
|
|
1654
|
-
|
|
1655
|
-
|
|
1656
|
-
|
|
1791
|
+
if (typeof value[1] == "number") {
|
|
1792
|
+
if (value[0] == "promise") {
|
|
1793
|
+
let hook = this.importer.importPromise(value[1]);
|
|
1794
|
+
let promise = new RpcPromise$1(hook, []);
|
|
1795
|
+
this.promises.push({
|
|
1796
|
+
parent,
|
|
1797
|
+
property,
|
|
1798
|
+
promise
|
|
1799
|
+
});
|
|
1800
|
+
return promise;
|
|
1801
|
+
} else {
|
|
1802
|
+
let hook = this.importer.importStub(value[1]);
|
|
1803
|
+
this.hooks.push(hook);
|
|
1804
|
+
return new RpcStub$1(hook);
|
|
1805
|
+
}
|
|
1657
1806
|
}
|
|
1658
1807
|
break;
|
|
1659
1808
|
case "writable":
|
|
@@ -1664,14 +1813,12 @@ var Evaluator = class Evaluator {
|
|
|
1664
1813
|
return stream;
|
|
1665
1814
|
}
|
|
1666
1815
|
break;
|
|
1667
|
-
case "readable":
|
|
1668
|
-
|
|
1669
|
-
|
|
1670
|
-
|
|
1671
|
-
|
|
1672
|
-
|
|
1673
|
-
}
|
|
1674
|
-
break;
|
|
1816
|
+
case "readable": if (typeof value[1] == "number") {
|
|
1817
|
+
let stream = this.importer.getPipeReadable(value[1]);
|
|
1818
|
+
let hook = streamImpl.createReadableStreamHook(stream);
|
|
1819
|
+
this.hooks.push(hook);
|
|
1820
|
+
return stream;
|
|
1821
|
+
}
|
|
1675
1822
|
}
|
|
1676
1823
|
throw new TypeError(`unknown special value: ${JSON.stringify(value)}`);
|
|
1677
1824
|
} else if (value instanceof Object) {
|
|
@@ -1716,6 +1863,7 @@ function estimateEncodedSize(value, seen, depth = 0) {
|
|
|
1716
1863
|
if (value instanceof ArrayBuffer) return ESTIMATED_BINARY_OVERHEAD + value.byteLength;
|
|
1717
1864
|
if (typeof Blob !== "undefined" && value instanceof Blob) return ESTIMATED_BINARY_OVERHEAD + value.size;
|
|
1718
1865
|
if (value instanceof Date) return 16;
|
|
1866
|
+
if (value instanceof RegExp) return ESTIMATED_OBJECT_OVERHEAD + estimateStringSize(value.source) + estimateStringSize(value.flags);
|
|
1719
1867
|
seen ??= /* @__PURE__ */ new WeakSet();
|
|
1720
1868
|
if (seen.has(value)) return ESTIMATED_ENTRY_OVERHEAD;
|
|
1721
1869
|
seen.add(value);
|
|
@@ -2036,7 +2184,7 @@ var RpcSessionImpl = class {
|
|
|
2036
2184
|
}
|
|
2037
2185
|
}
|
|
2038
2186
|
getImport(hook) {
|
|
2039
|
-
if (hook instanceof RpcImportHook && hook.entry && hook.entry.session === this) return hook.entry.importId;
|
|
2187
|
+
if (hook instanceof RpcImportHook && hook.entry && hook.entry.session === this && !hook.entry.resolution) return hook.entry.importId;
|
|
2040
2188
|
else return;
|
|
2041
2189
|
}
|
|
2042
2190
|
importStub(idx) {
|
|
@@ -2251,7 +2399,8 @@ var RpcSessionImpl = class {
|
|
|
2251
2399
|
if (msg instanceof Array) switch (msg[0]) {
|
|
2252
2400
|
case "push":
|
|
2253
2401
|
if (msg.length > 1) {
|
|
2254
|
-
let
|
|
2402
|
+
let payload = new Evaluator(this, this.encodingLevel).evaluate(msg[1]);
|
|
2403
|
+
let hook = new PayloadStubHook(payload);
|
|
2255
2404
|
hook.ignoreUnhandledRejections();
|
|
2256
2405
|
this.exports.push({
|
|
2257
2406
|
hook,
|
|
@@ -2262,7 +2411,8 @@ var RpcSessionImpl = class {
|
|
|
2262
2411
|
break;
|
|
2263
2412
|
case "stream":
|
|
2264
2413
|
if (msg.length > 1) {
|
|
2265
|
-
let
|
|
2414
|
+
let payload = new Evaluator(this, this.encodingLevel).evaluate(msg[1]);
|
|
2415
|
+
let hook = new PayloadStubHook(payload);
|
|
2266
2416
|
hook.ignoreUnhandledRejections();
|
|
2267
2417
|
let exportId = this.exports.length;
|
|
2268
2418
|
this.exports.push({
|
|
@@ -2297,13 +2447,14 @@ var RpcSessionImpl = class {
|
|
|
2297
2447
|
let importId = msg[1];
|
|
2298
2448
|
if (typeof importId == "number" && msg.length > 2) {
|
|
2299
2449
|
let imp = this.imports[importId];
|
|
2300
|
-
if (imp)
|
|
2301
|
-
|
|
2302
|
-
|
|
2303
|
-
|
|
2304
|
-
|
|
2305
|
-
|
|
2306
|
-
|
|
2450
|
+
if (imp) {
|
|
2451
|
+
if (msg[0] == "resolve") imp.resolve(new PayloadStubHook(new Evaluator(this, this.encodingLevel).evaluate(msg[2])));
|
|
2452
|
+
else {
|
|
2453
|
+
let payload = new Evaluator(this, this.encodingLevel).evaluate(msg[2]);
|
|
2454
|
+
payload.dispose();
|
|
2455
|
+
imp.resolve(new ErrorStubHook(payload.value));
|
|
2456
|
+
}
|
|
2457
|
+
} else if (msg[0] == "resolve") new Evaluator(this, this.encodingLevel).evaluate(msg[2]).dispose();
|
|
2307
2458
|
continue;
|
|
2308
2459
|
}
|
|
2309
2460
|
break;
|
|
@@ -2375,7 +2526,8 @@ var RpcSession$1 = class {
|
|
|
2375
2526
|
const MAX_CLOSE_REASON_BYTES = 123;
|
|
2376
2527
|
function newWebSocketRpcSession$1(webSocket, localMain, options) {
|
|
2377
2528
|
if (typeof webSocket === "string") webSocket = new WebSocket(webSocket);
|
|
2378
|
-
|
|
2529
|
+
let transport = new WebSocketTransport(webSocket);
|
|
2530
|
+
return new RpcSession$1(transport, localMain, options).getRemoteMain();
|
|
2379
2531
|
}
|
|
2380
2532
|
/**
|
|
2381
2533
|
* For use in Cloudflare Workers: Construct an HTTP response that starts a WebSocket RPC session
|
|
@@ -2412,12 +2564,13 @@ var WebSocketTransport = class {
|
|
|
2412
2564
|
});
|
|
2413
2565
|
}
|
|
2414
2566
|
webSocket.addEventListener("message", (event) => {
|
|
2415
|
-
if (this.#error) {} else if (typeof event.data === "string" || event.data instanceof ArrayBuffer)
|
|
2416
|
-
this.#receiveResolver
|
|
2417
|
-
|
|
2418
|
-
|
|
2419
|
-
|
|
2420
|
-
|
|
2567
|
+
if (this.#error) {} else if (typeof event.data === "string" || event.data instanceof ArrayBuffer) {
|
|
2568
|
+
if (this.#receiveResolver) {
|
|
2569
|
+
this.#receiveResolver(event.data);
|
|
2570
|
+
this.#receiveResolver = void 0;
|
|
2571
|
+
this.#receiveRejecter = void 0;
|
|
2572
|
+
} else this.#receiveQueue.push(event.data);
|
|
2573
|
+
} else this.#receivedError(/* @__PURE__ */ new TypeError("Received unexpected message type from WebSocket."));
|
|
2421
2574
|
});
|
|
2422
2575
|
webSocket.addEventListener("close", (event) => {
|
|
2423
2576
|
this.#receivedError(/* @__PURE__ */ new Error(`Peer closed WebSocket: ${event.code} ${event.reason}`));
|
|
@@ -2509,7 +2662,8 @@ function newHttpBatchRpcSession$1(urlOrRequest, options) {
|
|
|
2509
2662
|
let body = await response.text();
|
|
2510
2663
|
return body == "" ? [] : body.split("\n");
|
|
2511
2664
|
};
|
|
2512
|
-
|
|
2665
|
+
let transport = new BatchClientTransport(sendBatch);
|
|
2666
|
+
return new RpcSession$1(transport, void 0, options).getRemoteMain();
|
|
2513
2667
|
}
|
|
2514
2668
|
var BatchServerTransport = class {
|
|
2515
2669
|
constructor(batch) {
|
|
@@ -2552,7 +2706,8 @@ var BatchServerTransport = class {
|
|
|
2552
2706
|
async function newHttpBatchRpcResponse(request, localMain, options) {
|
|
2553
2707
|
if (request.method !== "POST") return new Response("This endpoint only accepts POST requests.", { status: 405 });
|
|
2554
2708
|
let body = await request.text();
|
|
2555
|
-
let
|
|
2709
|
+
let batch = body === "" ? [] : body.split("\n");
|
|
2710
|
+
let transport = new BatchServerTransport(batch);
|
|
2556
2711
|
let rpc = new RpcSession$1(transport, localMain, options);
|
|
2557
2712
|
await transport.whenAllReceived();
|
|
2558
2713
|
await rpc.drain();
|
|
@@ -2582,7 +2737,8 @@ async function nodeHttpBatchRpcResponse(request, response, localMain, options) {
|
|
|
2582
2737
|
});
|
|
2583
2738
|
request.on("error", reject);
|
|
2584
2739
|
});
|
|
2585
|
-
let
|
|
2740
|
+
let batch = body === "" ? [] : body.split("\n");
|
|
2741
|
+
let transport = new BatchServerTransport(batch);
|
|
2586
2742
|
let rpc = new RpcSession$1(transport, localMain, options);
|
|
2587
2743
|
await transport.whenAllReceived();
|
|
2588
2744
|
await rpc.drain();
|
|
@@ -2593,7 +2749,8 @@ async function nodeHttpBatchRpcResponse(request, response, localMain, options) {
|
|
|
2593
2749
|
//#endregion
|
|
2594
2750
|
//#region src/messageport.ts
|
|
2595
2751
|
function newMessagePortRpcSession$1(port, localMain, options) {
|
|
2596
|
-
|
|
2752
|
+
let transport = new MessagePortTransport(port);
|
|
2753
|
+
return new RpcSession$1(transport, localMain, options).getRemoteMain();
|
|
2597
2754
|
}
|
|
2598
2755
|
var MessagePortTransport = class {
|
|
2599
2756
|
encodingLevel = "structuredClonable";
|
|
@@ -2843,7 +3000,8 @@ var MapApplicator = class {
|
|
|
2843
3000
|
}
|
|
2844
3001
|
};
|
|
2845
3002
|
function applyMapToElement(input, parent, owner, captures, instructions) {
|
|
2846
|
-
let
|
|
3003
|
+
let inputHook = new PayloadStubHook(RpcPayload.deepCopyFrom(input, parent, owner));
|
|
3004
|
+
let mapper = new MapApplicator(captures, inputHook);
|
|
2847
3005
|
try {
|
|
2848
3006
|
return mapper.apply(instructions);
|
|
2849
3007
|
} finally {
|
|
@@ -2876,9 +3034,10 @@ mapImpl.applyMap = (input, parent, owner, captures, instructions) => {
|
|
|
2876
3034
|
var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
2877
3035
|
state;
|
|
2878
3036
|
static create(stream) {
|
|
3037
|
+
let writer = stream.getWriter();
|
|
2879
3038
|
return new WritableStreamStubHook({
|
|
2880
3039
|
refcount: 1,
|
|
2881
|
-
writer
|
|
3040
|
+
writer,
|
|
2882
3041
|
closed: false
|
|
2883
3042
|
});
|
|
2884
3043
|
}
|
|
@@ -2898,7 +3057,8 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2898
3057
|
const method = path[0];
|
|
2899
3058
|
if (method !== "write" && method !== "close" && method !== "abort") throw new Error(`Unknown WritableStream method: ${method}`);
|
|
2900
3059
|
if (method === "close" || method === "abort") state.closed = true;
|
|
2901
|
-
|
|
3060
|
+
let promise = method === "write" ? args.deliverStreamWrite(state.writer) : args.deliverCall(state.writer[method], state.writer);
|
|
3061
|
+
return new PromiseStubHook(promise.then((payload) => new PayloadStubHook(payload)));
|
|
2902
3062
|
} catch (err) {
|
|
2903
3063
|
args.dispose();
|
|
2904
3064
|
return new ErrorStubHook(err);
|
|
@@ -2912,7 +3072,8 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2912
3072
|
return new ErrorStubHook(/* @__PURE__ */ new Error("Cannot access properties on a WritableStream stub"));
|
|
2913
3073
|
}
|
|
2914
3074
|
dup() {
|
|
2915
|
-
|
|
3075
|
+
let state = this.getState();
|
|
3076
|
+
return new WritableStreamStubHook(state, this);
|
|
2916
3077
|
}
|
|
2917
3078
|
pull() {
|
|
2918
3079
|
return Promise.reject(/* @__PURE__ */ new Error("Cannot pull a WritableStream stub"));
|
|
@@ -2930,9 +3091,9 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2930
3091
|
}
|
|
2931
3092
|
onBroken(callback) {}
|
|
2932
3093
|
};
|
|
2933
|
-
const INITIAL_WINDOW =
|
|
2934
|
-
const MAX_WINDOW =
|
|
2935
|
-
const MIN_WINDOW =
|
|
3094
|
+
const INITIAL_WINDOW = 262144;
|
|
3095
|
+
const MAX_WINDOW = 1073741824;
|
|
3096
|
+
const MIN_WINDOW = 65536;
|
|
2936
3097
|
const STARTUP_GROWTH_FACTOR = 2;
|
|
2937
3098
|
const STEADY_GROWTH_FACTOR = 1.25;
|
|
2938
3099
|
const DECAY_FACTOR = .9;
|