capnweb 0.0.0-1cca1a2 → 0.0.0-2a02db9
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 +2 -1
- package/dist/index-bun.cjs +15 -164
- package/dist/index-bun.cjs.map +1 -1
- package/dist/index-bun.d.cts +0 -3
- package/dist/index-bun.d.ts +0 -3
- package/dist/index-bun.js +15 -164
- package/dist/index-bun.js.map +1 -1
- package/dist/index-workers.cjs +15 -164
- package/dist/index-workers.cjs.map +1 -1
- package/dist/index-workers.js +15 -164
- package/dist/index-workers.js.map +1 -1
- package/dist/index.cjs +15 -164
- package/dist/index.cjs.map +1 -1
- package/dist/index.js +15 -164
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -199,7 +199,7 @@ The following types can be passed over RPC (in arguments or return values), and
|
|
|
199
199
|
* Arrays
|
|
200
200
|
* `bigint`
|
|
201
201
|
* `Date`
|
|
202
|
-
* `
|
|
202
|
+
* `Uint8Array`
|
|
203
203
|
* `Error` and its well-known subclasses
|
|
204
204
|
* `Blob`
|
|
205
205
|
* `ReadableStream` and `WritableStream`, with automatic flow control.
|
|
@@ -207,6 +207,7 @@ The following types can be passed over RPC (in arguments or return values), and
|
|
|
207
207
|
|
|
208
208
|
The following types are not supported as of this writing, but may be added in the future:
|
|
209
209
|
* `Map` and `Set`
|
|
210
|
+
* `ArrayBuffer` and typed arrays other than `Uint8Array`
|
|
210
211
|
* `RegExp`
|
|
211
212
|
|
|
212
213
|
The following are intentionally NOT supported:
|
package/dist/index-bun.cjs
CHANGED
|
@@ -43,19 +43,7 @@ function typeForRpc(value) {
|
|
|
43
43
|
case Array.prototype: return "array";
|
|
44
44
|
case Date.prototype: return "date";
|
|
45
45
|
case Uint8Array.prototype:
|
|
46
|
-
case BUFFER_PROTOTYPE:
|
|
47
|
-
case ArrayBuffer.prototype:
|
|
48
|
-
case DataView.prototype:
|
|
49
|
-
case Int8Array.prototype:
|
|
50
|
-
case Uint8ClampedArray.prototype:
|
|
51
|
-
case Int16Array.prototype:
|
|
52
|
-
case Uint16Array.prototype:
|
|
53
|
-
case Int32Array.prototype:
|
|
54
|
-
case Uint32Array.prototype:
|
|
55
|
-
case BigInt64Array.prototype:
|
|
56
|
-
case BigUint64Array.prototype:
|
|
57
|
-
case Float32Array.prototype:
|
|
58
|
-
case Float64Array.prototype: return "bytes";
|
|
46
|
+
case BUFFER_PROTOTYPE: return "bytes";
|
|
59
47
|
case WritableStream.prototype: return "writable";
|
|
60
48
|
case ReadableStream.prototype: return "readable";
|
|
61
49
|
case Headers.prototype: return "headers";
|
|
@@ -525,30 +513,6 @@ var RpcPayload = class RpcPayload {
|
|
|
525
513
|
this.dispose();
|
|
526
514
|
}
|
|
527
515
|
}
|
|
528
|
-
async deliverStreamWrite(writer) {
|
|
529
|
-
try {
|
|
530
|
-
let promises = [];
|
|
531
|
-
this.deliverTo(this, "value", promises);
|
|
532
|
-
if (promises.length > 0) await Promise.all(promises);
|
|
533
|
-
let chunk = this.value[0];
|
|
534
|
-
if ((this.hooks.length > 0 || this.promises.length > 0) && chunk instanceof Object) {
|
|
535
|
-
if (!(Symbol.dispose in chunk)) Object.defineProperty(chunk, Symbol.dispose, {
|
|
536
|
-
value: () => this.dispose(),
|
|
537
|
-
writable: true,
|
|
538
|
-
enumerable: false,
|
|
539
|
-
configurable: true
|
|
540
|
-
});
|
|
541
|
-
await writer.write(chunk);
|
|
542
|
-
return RpcPayload.fromAppReturn(void 0);
|
|
543
|
-
}
|
|
544
|
-
await writer.write(chunk);
|
|
545
|
-
this.dispose();
|
|
546
|
-
return RpcPayload.fromAppReturn(void 0);
|
|
547
|
-
} catch (err) {
|
|
548
|
-
this.dispose();
|
|
549
|
-
throw err;
|
|
550
|
-
}
|
|
551
|
-
}
|
|
552
516
|
async deliverResolve() {
|
|
553
517
|
try {
|
|
554
518
|
let promises = [];
|
|
@@ -973,71 +937,6 @@ const DEFAULT_LIMITS = {
|
|
|
973
937
|
maxDepth: 256,
|
|
974
938
|
maxMessageSize: 32 * 1024 * 1024
|
|
975
939
|
};
|
|
976
|
-
const NATIVE_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
|
|
977
|
-
const BYTE_CONTAINER_TYPE_NAMES = [
|
|
978
|
-
"ArrayBuffer",
|
|
979
|
-
"DataView",
|
|
980
|
-
"Int8Array",
|
|
981
|
-
"Uint8Array",
|
|
982
|
-
"Uint8ClampedArray",
|
|
983
|
-
"Int16Array",
|
|
984
|
-
"Uint16Array",
|
|
985
|
-
"Int32Array",
|
|
986
|
-
"Uint32Array",
|
|
987
|
-
"BigInt64Array",
|
|
988
|
-
"BigUint64Array",
|
|
989
|
-
"Float32Array",
|
|
990
|
-
"Float64Array"
|
|
991
|
-
];
|
|
992
|
-
function isValidByteContainerName(value) {
|
|
993
|
-
return BYTE_CONTAINER_TYPE_NAMES.includes(value);
|
|
994
|
-
}
|
|
995
|
-
const TYPED_ARRAY_ELEMENT_SIZE = {
|
|
996
|
-
ArrayBuffer: void 0,
|
|
997
|
-
DataView: void 0,
|
|
998
|
-
Int8Array: void 0,
|
|
999
|
-
Uint8Array: void 0,
|
|
1000
|
-
Uint8ClampedArray: void 0,
|
|
1001
|
-
Int16Array: 2,
|
|
1002
|
-
Uint16Array: 2,
|
|
1003
|
-
Int32Array: 4,
|
|
1004
|
-
Uint32Array: 4,
|
|
1005
|
-
BigInt64Array: 8,
|
|
1006
|
-
BigUint64Array: 8,
|
|
1007
|
-
Float32Array: 4,
|
|
1008
|
-
Float64Array: 8
|
|
1009
|
-
};
|
|
1010
|
-
const BYTE_CONTAINER_PROTOTYPES = {
|
|
1011
|
-
ArrayBuffer: ArrayBuffer.prototype,
|
|
1012
|
-
DataView: DataView.prototype,
|
|
1013
|
-
Int8Array: Int8Array.prototype,
|
|
1014
|
-
Uint8ClampedArray: Uint8ClampedArray.prototype,
|
|
1015
|
-
Int16Array: Int16Array.prototype,
|
|
1016
|
-
Uint16Array: Uint16Array.prototype,
|
|
1017
|
-
Int32Array: Int32Array.prototype,
|
|
1018
|
-
Uint32Array: Uint32Array.prototype,
|
|
1019
|
-
BigInt64Array: BigInt64Array.prototype,
|
|
1020
|
-
BigUint64Array: BigUint64Array.prototype,
|
|
1021
|
-
Float32Array: Float32Array.prototype,
|
|
1022
|
-
Float64Array: Float64Array.prototype
|
|
1023
|
-
};
|
|
1024
|
-
const BYTE_CONTAINER_TYPE_BY_PROTOTYPE = /* @__PURE__ */ new Map();
|
|
1025
|
-
for (let type of Object.keys(BYTE_CONTAINER_PROTOTYPES)) BYTE_CONTAINER_TYPE_BY_PROTOTYPE.set(BYTE_CONTAINER_PROTOTYPES[type], type);
|
|
1026
|
-
function swapByteOrder(bytes, elementSize) {
|
|
1027
|
-
if (elementSize !== 2 && elementSize !== 4 && elementSize !== 8) throw new RangeError(`Unsupported element size: ${elementSize}`);
|
|
1028
|
-
let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
|
|
1029
|
-
for (let offset = 0; offset < bytes.byteLength; offset += elementSize) switch (elementSize) {
|
|
1030
|
-
case 2:
|
|
1031
|
-
view.setUint16(offset, view.getUint16(offset, false), true);
|
|
1032
|
-
break;
|
|
1033
|
-
case 4:
|
|
1034
|
-
view.setUint32(offset, view.getUint32(offset, false), true);
|
|
1035
|
-
break;
|
|
1036
|
-
case 8:
|
|
1037
|
-
view.setBigUint64(offset, view.getBigUint64(offset, false), true);
|
|
1038
|
-
break;
|
|
1039
|
-
}
|
|
1040
|
-
}
|
|
1041
940
|
var NullExporter = class {
|
|
1042
941
|
exportStub(stub) {
|
|
1043
942
|
throw new Error("Cannot serialize RPC stubs without an RPC session.");
|
|
@@ -1129,38 +1028,17 @@ var Devaluator = class Devaluator {
|
|
|
1129
1028
|
return ["date", Number.isNaN(time) ? null : time];
|
|
1130
1029
|
}
|
|
1131
1030
|
case "bytes": {
|
|
1132
|
-
let
|
|
1133
|
-
|
|
1134
|
-
if (
|
|
1135
|
-
else if (alternateTypeName === void 0) bytes = value;
|
|
1136
|
-
else {
|
|
1137
|
-
let view = value;
|
|
1138
|
-
bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
|
|
1139
|
-
let elementSize = TYPED_ARRAY_ELEMENT_SIZE[alternateTypeName];
|
|
1140
|
-
if (!NATIVE_LITTLE_ENDIAN && elementSize) {
|
|
1141
|
-
bytes = bytes.slice();
|
|
1142
|
-
swapByteOrder(bytes, elementSize);
|
|
1143
|
-
}
|
|
1144
|
-
}
|
|
1145
|
-
if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return alternateTypeName === void 0 ? ["bytes", bytes] : [
|
|
1146
|
-
"bytes",
|
|
1147
|
-
bytes,
|
|
1148
|
-
alternateTypeName
|
|
1149
|
-
];
|
|
1031
|
+
let bytes = value;
|
|
1032
|
+
if (this.encodingLevel === "structuredClonable" || this.encodingLevel === "jsonCompatibleWithBytes") return ["bytes", bytes];
|
|
1033
|
+
if (bytes.toBase64) return ["bytes", bytes.toBase64({ omitPadding: true })];
|
|
1150
1034
|
let b64;
|
|
1151
|
-
if (
|
|
1152
|
-
else if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
|
|
1035
|
+
if (typeof Buffer !== "undefined") b64 = (bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)).toString("base64");
|
|
1153
1036
|
else {
|
|
1154
1037
|
let binary = "";
|
|
1155
1038
|
for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
|
|
1156
1039
|
b64 = btoa(binary);
|
|
1157
1040
|
}
|
|
1158
|
-
|
|
1159
|
-
return alternateTypeName === void 0 ? ["bytes", b64] : [
|
|
1160
|
-
"bytes",
|
|
1161
|
-
b64,
|
|
1162
|
-
alternateTypeName
|
|
1163
|
-
];
|
|
1041
|
+
return ["bytes", b64.replace(/=+$/, "")];
|
|
1164
1042
|
}
|
|
1165
1043
|
case "headers": return ["headers", [...value]];
|
|
1166
1044
|
case "request": {
|
|
@@ -1413,46 +1291,18 @@ var Evaluator = class Evaluator {
|
|
|
1413
1291
|
if (value[1] === null) return /* @__PURE__ */ new Date(NaN);
|
|
1414
1292
|
if (typeof value[1] == "number") return new Date(value[1]);
|
|
1415
1293
|
break;
|
|
1416
|
-
case "bytes":
|
|
1417
|
-
|
|
1418
|
-
if (value[1]
|
|
1419
|
-
else if (
|
|
1420
|
-
else if (Uint8Array.fromBase64) bytes = Uint8Array.fromBase64(value[1]);
|
|
1294
|
+
case "bytes":
|
|
1295
|
+
if (value[1] instanceof Uint8Array) return value[1];
|
|
1296
|
+
if (typeof value[1] == "string") if (typeof Buffer !== "undefined") return Buffer.from(value[1], "base64");
|
|
1297
|
+
else if (Uint8Array.fromBase64) return Uint8Array.fromBase64(value[1]);
|
|
1421
1298
|
else {
|
|
1422
1299
|
let bs = atob(value[1]);
|
|
1423
1300
|
let len = bs.length;
|
|
1424
|
-
bytes = new Uint8Array(len);
|
|
1301
|
+
let bytes = new Uint8Array(len);
|
|
1425
1302
|
for (let i = 0; i < len; i++) bytes[i] = bs.charCodeAt(i);
|
|
1303
|
+
return bytes;
|
|
1426
1304
|
}
|
|
1427
|
-
|
|
1428
|
-
if (value.length === 2) return bytes;
|
|
1429
|
-
if (typeof value[2] !== "string") throw new TypeError(`Unknown bytes type marker type: ${typeof value[2]}`);
|
|
1430
|
-
if (!isValidByteContainerName(value[2])) {
|
|
1431
|
-
let marker = value[2].slice(0, 64);
|
|
1432
|
-
throw new TypeError(`Unknown bytes type marker: ${marker}`);
|
|
1433
|
-
}
|
|
1434
|
-
let marker = value[2];
|
|
1435
|
-
let elementSize = TYPED_ARRAY_ELEMENT_SIZE[marker];
|
|
1436
|
-
if (elementSize !== void 0 && bytes.byteLength % elementSize !== 0) throw new TypeError(`Invalid byte length ${bytes.byteLength} for ${marker}; expected a multiple of ${elementSize}`);
|
|
1437
|
-
let buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
1438
|
-
if (!NATIVE_LITTLE_ENDIAN && elementSize !== void 0) swapByteOrder(new Uint8Array(buffer), elementSize);
|
|
1439
|
-
switch (marker) {
|
|
1440
|
-
case "ArrayBuffer": return buffer;
|
|
1441
|
-
case "DataView": return new DataView(buffer);
|
|
1442
|
-
case "Int8Array": return new Int8Array(buffer);
|
|
1443
|
-
case "Uint8Array": return new Uint8Array(buffer);
|
|
1444
|
-
case "Uint8ClampedArray": return new Uint8ClampedArray(buffer);
|
|
1445
|
-
case "Int16Array": return new Int16Array(buffer);
|
|
1446
|
-
case "Uint16Array": return new Uint16Array(buffer);
|
|
1447
|
-
case "Int32Array": return new Int32Array(buffer);
|
|
1448
|
-
case "Uint32Array": return new Uint32Array(buffer);
|
|
1449
|
-
case "BigInt64Array": return new BigInt64Array(buffer);
|
|
1450
|
-
case "BigUint64Array": return new BigUint64Array(buffer);
|
|
1451
|
-
case "Float32Array": return new Float32Array(buffer);
|
|
1452
|
-
case "Float64Array": return new Float64Array(buffer);
|
|
1453
|
-
default:
|
|
1454
|
-
}
|
|
1455
|
-
}
|
|
1305
|
+
break;
|
|
1456
1306
|
case "error":
|
|
1457
1307
|
if (value.length >= 3 && typeof value[1] === "string" && typeof value[2] === "string") {
|
|
1458
1308
|
let cls = ERROR_TYPES[value[1]] || Error;
|
|
@@ -2828,7 +2678,8 @@ var WritableStreamStubHook = class WritableStreamStubHook extends StubHook {
|
|
|
2828
2678
|
throw new Error(`Unknown WritableStream method: ${method}`);
|
|
2829
2679
|
}
|
|
2830
2680
|
if (method === "close" || method === "abort") state.closed = true;
|
|
2831
|
-
|
|
2681
|
+
let func = state.writer[method];
|
|
2682
|
+
return new PromiseStubHook(args.deliverCall(func, state.writer).then((payload) => new PayloadStubHook(payload)));
|
|
2832
2683
|
} catch (err) {
|
|
2833
2684
|
return new ErrorStubHook(err);
|
|
2834
2685
|
}
|