@brickkit/cli 0.15.0 → 0.16.0-beta.0

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.
Files changed (86) hide show
  1. package/dashboard-dist/{CollapsiblePanel-CbUysOp5.js → CollapsiblePanel-DvJpFahB.js} +2 -2
  2. package/dashboard-dist/Geist-Variable.woff2 +0 -0
  3. package/dashboard-dist/GeistMono-Variable.woff2 +0 -0
  4. package/dashboard-dist/{api-reference-BP4ULs5J.js → api-reference-C2_JX174.js} +82 -70
  5. package/dashboard-dist/app.css +2 -2
  6. package/dashboard-dist/app.js +5 -5
  7. package/dashboard-dist/{client-CID_ep-s.js → client-DsITZplk.js} +1 -1
  8. package/dashboard-dist/{core-B123mLVe.js → core-sW89OSz5.js} +1 -1
  9. package/dashboard-dist/docs-D3U7gUWq.js +4 -0
  10. package/dashboard-dist/kit.js +1 -1
  11. package/dashboard-dist/{popover-B4rnc_po.js → popover-Bb2Q3jiK.js} +1 -1
  12. package/dist/bin.d.ts +1 -2
  13. package/dist/bin.js +6 -6
  14. package/dist/bin.js.map +1 -1
  15. package/dist/build.js.map +1 -1
  16. package/dist/client-contract-file.js +2 -1
  17. package/dist/client-contract-file.js.map +1 -1
  18. package/dist/compiler.d.ts +1 -2
  19. package/dist/config2.d.ts +1 -2
  20. package/dist/dashboard-extension.d.ts +1 -2
  21. package/dist/dashboard-host.js.map +1 -1
  22. package/dist/dashboard.d.ts +4 -4
  23. package/dist/definitions.js +1 -0
  24. package/dist/definitions.js.map +1 -1
  25. package/dist/dev-application.js.map +1 -1
  26. package/dist/dev-reporter.d.ts +1 -2
  27. package/dist/dev-reporter.js.map +1 -1
  28. package/dist/dev-telemetry.js.map +1 -1
  29. package/dist/dev-worker.js.map +1 -1
  30. package/dist/index.d.ts +1 -2
  31. package/dist/lint/oxlint.d.ts +1 -2
  32. package/dist/plugin.d.ts +1 -2
  33. package/dist/production-dashboard2.d.ts +1 -2
  34. package/dist/project.js +35 -12
  35. package/dist/project.js.map +1 -1
  36. package/dist/serve.d.ts +1 -2
  37. package/dist/serve2.js.map +1 -1
  38. package/dist/vite.d.ts +1 -2
  39. package/dist/vite.js.map +1 -1
  40. package/dist/workflows.d.ts +1 -2
  41. package/inspector-dist/client/assets/app-Wfnqu2Ic.css +4610 -0
  42. package/inspector-dist/client/assets/{dist-BK8w6xOr.js → dist-CEyPxAJU.js} +2008 -334
  43. package/inspector-dist/client/assets/{entry.client-D9jbgmTR.js → entry.client-Cszf0uLP.js} +4628 -2593
  44. package/inspector-dist/client/assets/highlighted-body-JLMTFACH-CgFt8UnP.js +41 -0
  45. package/inspector-dist/client/assets/{home-hwPlkNhv.js → home-B2m1nnIz.js} +191 -105
  46. package/inspector-dist/client/assets/{jsx-runtime-CPEah4WQ.js → jsx-runtime-DRYYXgdJ.js} +2946 -2001
  47. package/inspector-dist/client/assets/{manifest-0e76e9ac.js → manifest-cfc09adc.js} +1 -1
  48. package/inspector-dist/client/assets/mermaid-WFAXDIZX-BoRESrqm.js +1 -0
  49. package/inspector-dist/client/assets/root-CVescmwt.css +4544 -0
  50. package/inspector-dist/client/assets/{root-SLeEf-sT.js → root-CVhM1JOR.js} +3 -3
  51. package/inspector-dist/client/assets/{run-detail-DYbVkIFH.js → run-detail-BdV01jxD.js} +90 -50
  52. package/inspector-dist/client/assets/tabs-BVrPbzfI.css +66 -0
  53. package/inspector-dist/client/assets/{tabs-CaJisoyb.js → tabs-C2hdi5D4.js} +12496 -8708
  54. package/inspector-dist/client/assets/{zstd-browser-decoder-D94wmfAU.js → zstd-browser-decoder-DQWDmc2d.js} +2 -2
  55. package/inspector-dist/server/assets/{app-DGlfWVUI.js → app-w0nTXgJd.js} +51489 -51478
  56. package/inspector-dist/server/assets/{chunk-RLXIAIE6-F0SJZlei.js → chunk-7TTQLYRW-BO6_qAAU.js} +10986 -7848
  57. package/inspector-dist/server/assets/cjs-DPK66Gxq.js +3600 -0
  58. package/inspector-dist/server/assets/{dist-BCbwm6jl.js → dist-DTHqO9VA.js} +149 -1619
  59. package/inspector-dist/server/assets/{dist-Ce0I2PUv.js → dist-OLuKLJ4s.js} +8 -8
  60. package/inspector-dist/server/assets/{encryption-DdQgC8Rk.js → encryption-DMo4uOFN.js} +5 -5
  61. package/inspector-dist/server/assets/{event-metadata-n7E4zEmT.js → event-metadata-Bx8Ts484.js} +1 -1
  62. package/inspector-dist/server/assets/functions-B9XwHSzK.js +6972 -0
  63. package/inspector-dist/server/assets/{global-singleton-D8sIN5du.js → global-singleton-rNtXNHKV.js} +1 -1
  64. package/inspector-dist/server/assets/highlighted-body-JLMTFACH-B0HDNeQE.js +41 -0
  65. package/inspector-dist/server/assets/mermaid-WFAXDIZX-B-AIJZhh.js +1 -0
  66. package/inspector-dist/server/assets/serialization-DsMds3lJ.js +5716 -0
  67. package/inspector-dist/server/assets/{serialization-format-BbuGfHog.js → serialization-format-B27jSUCM.js} +30 -9
  68. package/inspector-dist/server/assets/state-resolver-DVs_zsEO.js +1422 -0
  69. package/inspector-dist/server/assets/{token-BgMmJNP5.js → token-CvvD8Y5H.js} +1 -1
  70. package/inspector-dist/server/assets/token-CxjWFNNq.js +63 -0
  71. package/inspector-dist/server/assets/token-util-D9IsWeEs.js +3 -0
  72. package/inspector-dist/server/assets/{wrapper-CIC3w0oC.js → wrapper-B_u9Z5Up.js} +58 -26
  73. package/inspector-dist/server/assets/{ws-transport-CxTYB11n.js → ws-transport-CamzQ5O8.js} +24379 -24240
  74. package/inspector-dist/server/assets/{zstd-browser-decoder-D7bCXbGg.js → zstd-browser-decoder-DlGbqUuc.js} +2 -2
  75. package/inspector-dist/server/index.js +1 -1
  76. package/package.json +21 -21
  77. package/dashboard-dist/docs-B5JrvjJm.js +0 -4
  78. package/inspector-dist/client/assets/app-CeSwVsRm.css +0 -2
  79. package/inspector-dist/client/assets/highlighted-body-B3W2YXNL-CfRnuITN.js +0 -34
  80. package/inspector-dist/client/assets/mermaid-3ZIDBTTL-ZDR2PNY_.js +0 -1
  81. package/inspector-dist/client/assets/root-ChBNTZd2.css +0 -2
  82. package/inspector-dist/client/assets/tabs-L5XKzOpP.css +0 -1
  83. package/inspector-dist/server/assets/functions-CNVQtbgg.js +0 -1170
  84. package/inspector-dist/server/assets/highlighted-body-B3W2YXNL-CWRzMxYD.js +0 -34
  85. package/inspector-dist/server/assets/mermaid-3ZIDBTTL-D0v0ngVr.js +0 -1
  86. package/inspector-dist/server/assets/parse-Begau9cA.js +0 -469
@@ -0,0 +1,3600 @@
1
+ import { i as __require, t as __commonJSMin } from "./rolldown-runtime-C1I3wEg2.js";
2
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/digest.js
3
+ var require_digest = /* @__PURE__ */ __commonJSMin(((exports) => {
4
+ Object.defineProperty(exports, "__esModule", { value: true });
5
+ var node_crypto_1 = __require("node:crypto");
6
+ var digest = (algorithm, data) => (0, node_crypto_1.createHash)(algorithm).update(data).digest();
7
+ exports.default = digest;
8
+ }));
9
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/buffer_utils.js
10
+ var require_buffer_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
11
+ Object.defineProperty(exports, "__esModule", { value: true });
12
+ exports.decoder = exports.encoder = void 0;
13
+ exports.concat = concat;
14
+ exports.p2s = p2s;
15
+ exports.uint64be = uint64be;
16
+ exports.uint32be = uint32be;
17
+ exports.lengthAndInput = lengthAndInput;
18
+ exports.concatKdf = concatKdf;
19
+ var digest_js_1 = require_digest();
20
+ exports.encoder = new TextEncoder();
21
+ exports.decoder = new TextDecoder();
22
+ var MAX_INT32 = 2 ** 32;
23
+ function concat(...buffers) {
24
+ const size = buffers.reduce((acc, { length }) => acc + length, 0);
25
+ const buf = new Uint8Array(size);
26
+ let i = 0;
27
+ for (const buffer of buffers) {
28
+ buf.set(buffer, i);
29
+ i += buffer.length;
30
+ }
31
+ return buf;
32
+ }
33
+ function p2s(alg, p2sInput) {
34
+ return concat(exports.encoder.encode(alg), new Uint8Array([0]), p2sInput);
35
+ }
36
+ function writeUInt32BE(buf, value, offset) {
37
+ if (value < 0 || value >= MAX_INT32) throw new RangeError(`value must be >= 0 and <= ${MAX_INT32 - 1}. Received ${value}`);
38
+ buf.set([
39
+ value >>> 24,
40
+ value >>> 16,
41
+ value >>> 8,
42
+ value & 255
43
+ ], offset);
44
+ }
45
+ function uint64be(value) {
46
+ const high = Math.floor(value / MAX_INT32);
47
+ const low = value % MAX_INT32;
48
+ const buf = /* @__PURE__ */ new Uint8Array(8);
49
+ writeUInt32BE(buf, high, 0);
50
+ writeUInt32BE(buf, low, 4);
51
+ return buf;
52
+ }
53
+ function uint32be(value) {
54
+ const buf = /* @__PURE__ */ new Uint8Array(4);
55
+ writeUInt32BE(buf, value);
56
+ return buf;
57
+ }
58
+ function lengthAndInput(input) {
59
+ return concat(uint32be(input.length), input);
60
+ }
61
+ async function concatKdf(secret, bits, value) {
62
+ const iterations = Math.ceil((bits >> 3) / 32);
63
+ const res = new Uint8Array(iterations * 32);
64
+ for (let iter = 0; iter < iterations; iter++) {
65
+ const buf = new Uint8Array(4 + secret.length + value.length);
66
+ buf.set(uint32be(iter + 1));
67
+ buf.set(secret, 4);
68
+ buf.set(value, 4 + secret.length);
69
+ res.set(await (0, digest_js_1.default)("sha256", buf), iter * 32);
70
+ }
71
+ return res.slice(0, bits >> 3);
72
+ }
73
+ }));
74
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/base64url.js
75
+ var require_base64url$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
76
+ Object.defineProperty(exports, "__esModule", { value: true });
77
+ exports.decode = exports.encode = exports.encodeBase64 = exports.decodeBase64 = void 0;
78
+ var node_buffer_1 = __require("node:buffer");
79
+ var buffer_utils_js_1 = require_buffer_utils();
80
+ function normalize(input) {
81
+ let encoded = input;
82
+ if (encoded instanceof Uint8Array) encoded = buffer_utils_js_1.decoder.decode(encoded);
83
+ return encoded;
84
+ }
85
+ var encode = (input) => node_buffer_1.Buffer.from(input).toString("base64url");
86
+ exports.encode = encode;
87
+ var decodeBase64 = (input) => new Uint8Array(node_buffer_1.Buffer.from(input, "base64"));
88
+ exports.decodeBase64 = decodeBase64;
89
+ var encodeBase64 = (input) => node_buffer_1.Buffer.from(input).toString("base64");
90
+ exports.encodeBase64 = encodeBase64;
91
+ var decode = (input) => new Uint8Array(node_buffer_1.Buffer.from(normalize(input), "base64url"));
92
+ exports.decode = decode;
93
+ }));
94
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/util/errors.js
95
+ var require_errors = /* @__PURE__ */ __commonJSMin(((exports) => {
96
+ Object.defineProperty(exports, "__esModule", { value: true });
97
+ exports.JWSSignatureVerificationFailed = exports.JWKSTimeout = exports.JWKSMultipleMatchingKeys = exports.JWKSNoMatchingKey = exports.JWKSInvalid = exports.JWKInvalid = exports.JWTInvalid = exports.JWSInvalid = exports.JWEInvalid = exports.JWEDecryptionFailed = exports.JOSENotSupported = exports.JOSEAlgNotAllowed = exports.JWTExpired = exports.JWTClaimValidationFailed = exports.JOSEError = void 0;
98
+ var JOSEError = class extends Error {
99
+ static code = "ERR_JOSE_GENERIC";
100
+ code = "ERR_JOSE_GENERIC";
101
+ constructor(message, options) {
102
+ super(message, options);
103
+ this.name = this.constructor.name;
104
+ Error.captureStackTrace?.(this, this.constructor);
105
+ }
106
+ };
107
+ exports.JOSEError = JOSEError;
108
+ var JWTClaimValidationFailed = class extends JOSEError {
109
+ static code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
110
+ code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
111
+ claim;
112
+ reason;
113
+ payload;
114
+ constructor(message, payload, claim = "unspecified", reason = "unspecified") {
115
+ super(message, { cause: {
116
+ claim,
117
+ reason,
118
+ payload
119
+ } });
120
+ this.claim = claim;
121
+ this.reason = reason;
122
+ this.payload = payload;
123
+ }
124
+ };
125
+ exports.JWTClaimValidationFailed = JWTClaimValidationFailed;
126
+ var JWTExpired = class extends JOSEError {
127
+ static code = "ERR_JWT_EXPIRED";
128
+ code = "ERR_JWT_EXPIRED";
129
+ claim;
130
+ reason;
131
+ payload;
132
+ constructor(message, payload, claim = "unspecified", reason = "unspecified") {
133
+ super(message, { cause: {
134
+ claim,
135
+ reason,
136
+ payload
137
+ } });
138
+ this.claim = claim;
139
+ this.reason = reason;
140
+ this.payload = payload;
141
+ }
142
+ };
143
+ exports.JWTExpired = JWTExpired;
144
+ var JOSEAlgNotAllowed = class extends JOSEError {
145
+ static code = "ERR_JOSE_ALG_NOT_ALLOWED";
146
+ code = "ERR_JOSE_ALG_NOT_ALLOWED";
147
+ };
148
+ exports.JOSEAlgNotAllowed = JOSEAlgNotAllowed;
149
+ var JOSENotSupported = class extends JOSEError {
150
+ static code = "ERR_JOSE_NOT_SUPPORTED";
151
+ code = "ERR_JOSE_NOT_SUPPORTED";
152
+ };
153
+ exports.JOSENotSupported = JOSENotSupported;
154
+ var JWEDecryptionFailed = class extends JOSEError {
155
+ static code = "ERR_JWE_DECRYPTION_FAILED";
156
+ code = "ERR_JWE_DECRYPTION_FAILED";
157
+ constructor(message = "decryption operation failed", options) {
158
+ super(message, options);
159
+ }
160
+ };
161
+ exports.JWEDecryptionFailed = JWEDecryptionFailed;
162
+ var JWEInvalid = class extends JOSEError {
163
+ static code = "ERR_JWE_INVALID";
164
+ code = "ERR_JWE_INVALID";
165
+ };
166
+ exports.JWEInvalid = JWEInvalid;
167
+ var JWSInvalid = class extends JOSEError {
168
+ static code = "ERR_JWS_INVALID";
169
+ code = "ERR_JWS_INVALID";
170
+ };
171
+ exports.JWSInvalid = JWSInvalid;
172
+ var JWTInvalid = class extends JOSEError {
173
+ static code = "ERR_JWT_INVALID";
174
+ code = "ERR_JWT_INVALID";
175
+ };
176
+ exports.JWTInvalid = JWTInvalid;
177
+ var JWKInvalid = class extends JOSEError {
178
+ static code = "ERR_JWK_INVALID";
179
+ code = "ERR_JWK_INVALID";
180
+ };
181
+ exports.JWKInvalid = JWKInvalid;
182
+ var JWKSInvalid = class extends JOSEError {
183
+ static code = "ERR_JWKS_INVALID";
184
+ code = "ERR_JWKS_INVALID";
185
+ };
186
+ exports.JWKSInvalid = JWKSInvalid;
187
+ var JWKSNoMatchingKey = class extends JOSEError {
188
+ static code = "ERR_JWKS_NO_MATCHING_KEY";
189
+ code = "ERR_JWKS_NO_MATCHING_KEY";
190
+ constructor(message = "no applicable key found in the JSON Web Key Set", options) {
191
+ super(message, options);
192
+ }
193
+ };
194
+ exports.JWKSNoMatchingKey = JWKSNoMatchingKey;
195
+ var JWKSMultipleMatchingKeys = class extends JOSEError {
196
+ [Symbol.asyncIterator];
197
+ static code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS";
198
+ code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS";
199
+ constructor(message = "multiple matching keys found in the JSON Web Key Set", options) {
200
+ super(message, options);
201
+ }
202
+ };
203
+ exports.JWKSMultipleMatchingKeys = JWKSMultipleMatchingKeys;
204
+ var JWKSTimeout = class extends JOSEError {
205
+ static code = "ERR_JWKS_TIMEOUT";
206
+ code = "ERR_JWKS_TIMEOUT";
207
+ constructor(message = "request timed out", options) {
208
+ super(message, options);
209
+ }
210
+ };
211
+ exports.JWKSTimeout = JWKSTimeout;
212
+ var JWSSignatureVerificationFailed = class extends JOSEError {
213
+ static code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
214
+ code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
215
+ constructor(message = "signature verification failed", options) {
216
+ super(message, options);
217
+ }
218
+ };
219
+ exports.JWSSignatureVerificationFailed = JWSSignatureVerificationFailed;
220
+ }));
221
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/random.js
222
+ var require_random = /* @__PURE__ */ __commonJSMin(((exports) => {
223
+ Object.defineProperty(exports, "__esModule", { value: true });
224
+ exports.default = void 0;
225
+ var node_crypto_1 = __require("node:crypto");
226
+ Object.defineProperty(exports, "default", {
227
+ enumerable: true,
228
+ get: function() {
229
+ return node_crypto_1.randomFillSync;
230
+ }
231
+ });
232
+ }));
233
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/iv.js
234
+ var require_iv = /* @__PURE__ */ __commonJSMin(((exports) => {
235
+ Object.defineProperty(exports, "__esModule", { value: true });
236
+ exports.bitLength = bitLength;
237
+ var errors_js_1 = require_errors();
238
+ var random_js_1 = require_random();
239
+ function bitLength(alg) {
240
+ switch (alg) {
241
+ case "A128GCM":
242
+ case "A128GCMKW":
243
+ case "A192GCM":
244
+ case "A192GCMKW":
245
+ case "A256GCM":
246
+ case "A256GCMKW": return 96;
247
+ case "A128CBC-HS256":
248
+ case "A192CBC-HS384":
249
+ case "A256CBC-HS512": return 128;
250
+ default: throw new errors_js_1.JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
251
+ }
252
+ }
253
+ exports.default = (alg) => (0, random_js_1.default)(new Uint8Array(bitLength(alg) >> 3));
254
+ }));
255
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/check_iv_length.js
256
+ var require_check_iv_length = /* @__PURE__ */ __commonJSMin(((exports) => {
257
+ Object.defineProperty(exports, "__esModule", { value: true });
258
+ var errors_js_1 = require_errors();
259
+ var iv_js_1 = require_iv();
260
+ var checkIvLength = (enc, iv) => {
261
+ if (iv.length << 3 !== (0, iv_js_1.bitLength)(enc)) throw new errors_js_1.JWEInvalid("Invalid Initialization Vector length");
262
+ };
263
+ exports.default = checkIvLength;
264
+ }));
265
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/is_key_object.js
266
+ var require_is_key_object = /* @__PURE__ */ __commonJSMin(((exports) => {
267
+ Object.defineProperty(exports, "__esModule", { value: true });
268
+ var util = __require("node:util");
269
+ exports.default = (obj) => util.types.isKeyObject(obj);
270
+ }));
271
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/check_cek_length.js
272
+ var require_check_cek_length = /* @__PURE__ */ __commonJSMin(((exports) => {
273
+ Object.defineProperty(exports, "__esModule", { value: true });
274
+ var errors_js_1 = require_errors();
275
+ var is_key_object_js_1 = require_is_key_object();
276
+ var checkCekLength = (enc, cek) => {
277
+ let expected;
278
+ switch (enc) {
279
+ case "A128CBC-HS256":
280
+ case "A192CBC-HS384":
281
+ case "A256CBC-HS512":
282
+ expected = parseInt(enc.slice(-3), 10);
283
+ break;
284
+ case "A128GCM":
285
+ case "A192GCM":
286
+ case "A256GCM":
287
+ expected = parseInt(enc.slice(1, 4), 10);
288
+ break;
289
+ default: throw new errors_js_1.JOSENotSupported(`Content Encryption Algorithm ${enc} is not supported either by JOSE or your javascript runtime`);
290
+ }
291
+ if (cek instanceof Uint8Array) {
292
+ const actual = cek.byteLength << 3;
293
+ if (actual !== expected) throw new errors_js_1.JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
294
+ return;
295
+ }
296
+ if ((0, is_key_object_js_1.default)(cek) && cek.type === "secret") {
297
+ const actual = cek.symmetricKeySize << 3;
298
+ if (actual !== expected) throw new errors_js_1.JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
299
+ return;
300
+ }
301
+ throw new TypeError("Invalid Content Encryption Key type");
302
+ };
303
+ exports.default = checkCekLength;
304
+ }));
305
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/timing_safe_equal.js
306
+ var require_timing_safe_equal = /* @__PURE__ */ __commonJSMin(((exports) => {
307
+ Object.defineProperty(exports, "__esModule", { value: true });
308
+ exports.default = __require("node:crypto").timingSafeEqual;
309
+ }));
310
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/cbc_tag.js
311
+ var require_cbc_tag = /* @__PURE__ */ __commonJSMin(((exports) => {
312
+ Object.defineProperty(exports, "__esModule", { value: true });
313
+ exports.default = cbcTag;
314
+ var node_crypto_1 = __require("node:crypto");
315
+ var buffer_utils_js_1 = require_buffer_utils();
316
+ function cbcTag(aad, iv, ciphertext, macSize, macKey, keySize) {
317
+ const macData = (0, buffer_utils_js_1.concat)(aad, iv, ciphertext, (0, buffer_utils_js_1.uint64be)(aad.length << 3));
318
+ const hmac = (0, node_crypto_1.createHmac)(`sha${macSize}`, macKey);
319
+ hmac.update(macData);
320
+ return hmac.digest().slice(0, keySize >> 3);
321
+ }
322
+ }));
323
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/webcrypto.js
324
+ var require_webcrypto = /* @__PURE__ */ __commonJSMin(((exports) => {
325
+ Object.defineProperty(exports, "__esModule", { value: true });
326
+ exports.isCryptoKey = void 0;
327
+ var crypto = __require("node:crypto");
328
+ var util = __require("node:util");
329
+ exports.default = crypto.webcrypto;
330
+ var isCryptoKey = (key) => util.types.isCryptoKey(key);
331
+ exports.isCryptoKey = isCryptoKey;
332
+ }));
333
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/crypto_key.js
334
+ var require_crypto_key = /* @__PURE__ */ __commonJSMin(((exports) => {
335
+ Object.defineProperty(exports, "__esModule", { value: true });
336
+ exports.checkSigCryptoKey = checkSigCryptoKey;
337
+ exports.checkEncCryptoKey = checkEncCryptoKey;
338
+ function unusable(name, prop = "algorithm.name") {
339
+ return /* @__PURE__ */ new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
340
+ }
341
+ function isAlgorithm(algorithm, name) {
342
+ return algorithm.name === name;
343
+ }
344
+ function getHashLength(hash) {
345
+ return parseInt(hash.name.slice(4), 10);
346
+ }
347
+ function getNamedCurve(alg) {
348
+ switch (alg) {
349
+ case "ES256": return "P-256";
350
+ case "ES384": return "P-384";
351
+ case "ES512": return "P-521";
352
+ default: throw new Error("unreachable");
353
+ }
354
+ }
355
+ function checkUsage(key, usages) {
356
+ if (usages.length && !usages.some((expected) => key.usages.includes(expected))) {
357
+ let msg = "CryptoKey does not support this operation, its usages must include ";
358
+ if (usages.length > 2) {
359
+ const last = usages.pop();
360
+ msg += `one of ${usages.join(", ")}, or ${last}.`;
361
+ } else if (usages.length === 2) msg += `one of ${usages[0]} or ${usages[1]}.`;
362
+ else msg += `${usages[0]}.`;
363
+ throw new TypeError(msg);
364
+ }
365
+ }
366
+ function checkSigCryptoKey(key, alg, ...usages) {
367
+ switch (alg) {
368
+ case "HS256":
369
+ case "HS384":
370
+ case "HS512": {
371
+ if (!isAlgorithm(key.algorithm, "HMAC")) throw unusable("HMAC");
372
+ const expected = parseInt(alg.slice(2), 10);
373
+ if (getHashLength(key.algorithm.hash) !== expected) throw unusable(`SHA-${expected}`, "algorithm.hash");
374
+ break;
375
+ }
376
+ case "RS256":
377
+ case "RS384":
378
+ case "RS512": {
379
+ if (!isAlgorithm(key.algorithm, "RSASSA-PKCS1-v1_5")) throw unusable("RSASSA-PKCS1-v1_5");
380
+ const expected = parseInt(alg.slice(2), 10);
381
+ if (getHashLength(key.algorithm.hash) !== expected) throw unusable(`SHA-${expected}`, "algorithm.hash");
382
+ break;
383
+ }
384
+ case "PS256":
385
+ case "PS384":
386
+ case "PS512": {
387
+ if (!isAlgorithm(key.algorithm, "RSA-PSS")) throw unusable("RSA-PSS");
388
+ const expected = parseInt(alg.slice(2), 10);
389
+ if (getHashLength(key.algorithm.hash) !== expected) throw unusable(`SHA-${expected}`, "algorithm.hash");
390
+ break;
391
+ }
392
+ case "EdDSA":
393
+ if (key.algorithm.name !== "Ed25519" && key.algorithm.name !== "Ed448") throw unusable("Ed25519 or Ed448");
394
+ break;
395
+ case "Ed25519":
396
+ if (!isAlgorithm(key.algorithm, "Ed25519")) throw unusable("Ed25519");
397
+ break;
398
+ case "ES256":
399
+ case "ES384":
400
+ case "ES512": {
401
+ if (!isAlgorithm(key.algorithm, "ECDSA")) throw unusable("ECDSA");
402
+ const expected = getNamedCurve(alg);
403
+ if (key.algorithm.namedCurve !== expected) throw unusable(expected, "algorithm.namedCurve");
404
+ break;
405
+ }
406
+ default: throw new TypeError("CryptoKey does not support this operation");
407
+ }
408
+ checkUsage(key, usages);
409
+ }
410
+ function checkEncCryptoKey(key, alg, ...usages) {
411
+ switch (alg) {
412
+ case "A128GCM":
413
+ case "A192GCM":
414
+ case "A256GCM": {
415
+ if (!isAlgorithm(key.algorithm, "AES-GCM")) throw unusable("AES-GCM");
416
+ const expected = parseInt(alg.slice(1, 4), 10);
417
+ if (key.algorithm.length !== expected) throw unusable(expected, "algorithm.length");
418
+ break;
419
+ }
420
+ case "A128KW":
421
+ case "A192KW":
422
+ case "A256KW": {
423
+ if (!isAlgorithm(key.algorithm, "AES-KW")) throw unusable("AES-KW");
424
+ const expected = parseInt(alg.slice(1, 4), 10);
425
+ if (key.algorithm.length !== expected) throw unusable(expected, "algorithm.length");
426
+ break;
427
+ }
428
+ case "ECDH":
429
+ switch (key.algorithm.name) {
430
+ case "ECDH":
431
+ case "X25519":
432
+ case "X448": break;
433
+ default: throw unusable("ECDH, X25519, or X448");
434
+ }
435
+ break;
436
+ case "PBES2-HS256+A128KW":
437
+ case "PBES2-HS384+A192KW":
438
+ case "PBES2-HS512+A256KW":
439
+ if (!isAlgorithm(key.algorithm, "PBKDF2")) throw unusable("PBKDF2");
440
+ break;
441
+ case "RSA-OAEP":
442
+ case "RSA-OAEP-256":
443
+ case "RSA-OAEP-384":
444
+ case "RSA-OAEP-512": {
445
+ if (!isAlgorithm(key.algorithm, "RSA-OAEP")) throw unusable("RSA-OAEP");
446
+ const expected = parseInt(alg.slice(9), 10) || 1;
447
+ if (getHashLength(key.algorithm.hash) !== expected) throw unusable(`SHA-${expected}`, "algorithm.hash");
448
+ break;
449
+ }
450
+ default: throw new TypeError("CryptoKey does not support this operation");
451
+ }
452
+ checkUsage(key, usages);
453
+ }
454
+ }));
455
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/invalid_key_input.js
456
+ var require_invalid_key_input = /* @__PURE__ */ __commonJSMin(((exports) => {
457
+ Object.defineProperty(exports, "__esModule", { value: true });
458
+ exports.withAlg = withAlg;
459
+ function message(msg, actual, ...types) {
460
+ types = types.filter(Boolean);
461
+ if (types.length > 2) {
462
+ const last = types.pop();
463
+ msg += `one of type ${types.join(", ")}, or ${last}.`;
464
+ } else if (types.length === 2) msg += `one of type ${types[0]} or ${types[1]}.`;
465
+ else msg += `of type ${types[0]}.`;
466
+ if (actual == null) msg += ` Received ${actual}`;
467
+ else if (typeof actual === "function" && actual.name) msg += ` Received function ${actual.name}`;
468
+ else if (typeof actual === "object" && actual != null) {
469
+ if (actual.constructor?.name) msg += ` Received an instance of ${actual.constructor.name}`;
470
+ }
471
+ return msg;
472
+ }
473
+ exports.default = (actual, ...types) => {
474
+ return message("Key must be ", actual, ...types);
475
+ };
476
+ function withAlg(alg, actual, ...types) {
477
+ return message(`Key for the ${alg} algorithm must be `, actual, ...types);
478
+ }
479
+ }));
480
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/ciphers.js
481
+ var require_ciphers = /* @__PURE__ */ __commonJSMin(((exports) => {
482
+ Object.defineProperty(exports, "__esModule", { value: true });
483
+ var node_crypto_1 = __require("node:crypto");
484
+ var ciphers;
485
+ exports.default = (algorithm) => {
486
+ ciphers ||= new Set((0, node_crypto_1.getCiphers)());
487
+ return ciphers.has(algorithm);
488
+ };
489
+ }));
490
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/is_key_like.js
491
+ var require_is_key_like = /* @__PURE__ */ __commonJSMin(((exports) => {
492
+ Object.defineProperty(exports, "__esModule", { value: true });
493
+ exports.types = void 0;
494
+ var webcrypto_js_1 = require_webcrypto();
495
+ var is_key_object_js_1 = require_is_key_object();
496
+ exports.default = (key) => (0, is_key_object_js_1.default)(key) || (0, webcrypto_js_1.isCryptoKey)(key);
497
+ var types = ["KeyObject"];
498
+ exports.types = types;
499
+ if (globalThis.CryptoKey || webcrypto_js_1.default?.CryptoKey) types.push("CryptoKey");
500
+ }));
501
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/decrypt.js
502
+ var require_decrypt$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
503
+ Object.defineProperty(exports, "__esModule", { value: true });
504
+ var node_crypto_1 = __require("node:crypto");
505
+ var check_iv_length_js_1 = require_check_iv_length();
506
+ var check_cek_length_js_1 = require_check_cek_length();
507
+ var buffer_utils_js_1 = require_buffer_utils();
508
+ var errors_js_1 = require_errors();
509
+ var timing_safe_equal_js_1 = require_timing_safe_equal();
510
+ var cbc_tag_js_1 = require_cbc_tag();
511
+ var webcrypto_js_1 = require_webcrypto();
512
+ var crypto_key_js_1 = require_crypto_key();
513
+ var is_key_object_js_1 = require_is_key_object();
514
+ var invalid_key_input_js_1 = require_invalid_key_input();
515
+ var ciphers_js_1 = require_ciphers();
516
+ var is_key_like_js_1 = require_is_key_like();
517
+ function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
518
+ const keySize = parseInt(enc.slice(1, 4), 10);
519
+ if ((0, is_key_object_js_1.default)(cek)) cek = cek.export();
520
+ const encKey = cek.subarray(keySize >> 3);
521
+ const macKey = cek.subarray(0, keySize >> 3);
522
+ const macSize = parseInt(enc.slice(-3), 10);
523
+ const algorithm = `aes-${keySize}-cbc`;
524
+ if (!(0, ciphers_js_1.default)(algorithm)) throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
525
+ const expectedTag = (0, cbc_tag_js_1.default)(aad, iv, ciphertext, macSize, macKey, keySize);
526
+ let macCheckPassed;
527
+ try {
528
+ macCheckPassed = (0, timing_safe_equal_js_1.default)(tag, expectedTag);
529
+ } catch {}
530
+ if (!macCheckPassed) throw new errors_js_1.JWEDecryptionFailed();
531
+ let plaintext;
532
+ try {
533
+ const decipher = (0, node_crypto_1.createDecipheriv)(algorithm, encKey, iv);
534
+ plaintext = (0, buffer_utils_js_1.concat)(decipher.update(ciphertext), decipher.final());
535
+ } catch {}
536
+ if (!plaintext) throw new errors_js_1.JWEDecryptionFailed();
537
+ return plaintext;
538
+ }
539
+ function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
540
+ const algorithm = `aes-${parseInt(enc.slice(1, 4), 10)}-gcm`;
541
+ if (!(0, ciphers_js_1.default)(algorithm)) throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
542
+ try {
543
+ const decipher = (0, node_crypto_1.createDecipheriv)(algorithm, cek, iv, { authTagLength: 16 });
544
+ decipher.setAuthTag(tag);
545
+ if (aad.byteLength) decipher.setAAD(aad, { plaintextLength: ciphertext.length });
546
+ const plaintext = decipher.update(ciphertext);
547
+ decipher.final();
548
+ return plaintext;
549
+ } catch {
550
+ throw new errors_js_1.JWEDecryptionFailed();
551
+ }
552
+ }
553
+ var decrypt = (enc, cek, ciphertext, iv, tag, aad) => {
554
+ let key;
555
+ if ((0, webcrypto_js_1.isCryptoKey)(cek)) {
556
+ (0, crypto_key_js_1.checkEncCryptoKey)(cek, enc, "decrypt");
557
+ key = node_crypto_1.KeyObject.from(cek);
558
+ } else if (cek instanceof Uint8Array || (0, is_key_object_js_1.default)(cek)) key = cek;
559
+ else throw new TypeError((0, invalid_key_input_js_1.default)(cek, ...is_key_like_js_1.types, "Uint8Array"));
560
+ if (!iv) throw new errors_js_1.JWEInvalid("JWE Initialization Vector missing");
561
+ if (!tag) throw new errors_js_1.JWEInvalid("JWE Authentication Tag missing");
562
+ (0, check_cek_length_js_1.default)(enc, key);
563
+ (0, check_iv_length_js_1.default)(enc, iv);
564
+ switch (enc) {
565
+ case "A128CBC-HS256":
566
+ case "A192CBC-HS384":
567
+ case "A256CBC-HS512": return cbcDecrypt(enc, key, ciphertext, iv, tag, aad);
568
+ case "A128GCM":
569
+ case "A192GCM":
570
+ case "A256GCM": return gcmDecrypt(enc, key, ciphertext, iv, tag, aad);
571
+ default: throw new errors_js_1.JOSENotSupported("Unsupported JWE Content Encryption Algorithm");
572
+ }
573
+ };
574
+ exports.default = decrypt;
575
+ }));
576
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/is_disjoint.js
577
+ var require_is_disjoint = /* @__PURE__ */ __commonJSMin(((exports) => {
578
+ Object.defineProperty(exports, "__esModule", { value: true });
579
+ var isDisjoint = (...headers) => {
580
+ const sources = headers.filter(Boolean);
581
+ if (sources.length === 0 || sources.length === 1) return true;
582
+ let acc;
583
+ for (const header of sources) {
584
+ const parameters = Object.keys(header);
585
+ if (!acc || acc.size === 0) {
586
+ acc = new Set(parameters);
587
+ continue;
588
+ }
589
+ for (const parameter of parameters) {
590
+ if (acc.has(parameter)) return false;
591
+ acc.add(parameter);
592
+ }
593
+ }
594
+ return true;
595
+ };
596
+ exports.default = isDisjoint;
597
+ }));
598
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/is_object.js
599
+ var require_is_object = /* @__PURE__ */ __commonJSMin(((exports) => {
600
+ Object.defineProperty(exports, "__esModule", { value: true });
601
+ exports.default = isObject;
602
+ function isObjectLike(value) {
603
+ return typeof value === "object" && value !== null;
604
+ }
605
+ function isObject(input) {
606
+ if (!isObjectLike(input) || Object.prototype.toString.call(input) !== "[object Object]") return false;
607
+ if (Object.getPrototypeOf(input) === null) return true;
608
+ let proto = input;
609
+ while (Object.getPrototypeOf(proto) !== null) proto = Object.getPrototypeOf(proto);
610
+ return Object.getPrototypeOf(input) === proto;
611
+ }
612
+ }));
613
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/aeskw.js
614
+ var require_aeskw = /* @__PURE__ */ __commonJSMin(((exports) => {
615
+ Object.defineProperty(exports, "__esModule", { value: true });
616
+ exports.unwrap = exports.wrap = void 0;
617
+ var node_buffer_1 = __require("node:buffer");
618
+ var node_crypto_1 = __require("node:crypto");
619
+ var errors_js_1 = require_errors();
620
+ var buffer_utils_js_1 = require_buffer_utils();
621
+ var webcrypto_js_1 = require_webcrypto();
622
+ var crypto_key_js_1 = require_crypto_key();
623
+ var is_key_object_js_1 = require_is_key_object();
624
+ var invalid_key_input_js_1 = require_invalid_key_input();
625
+ var ciphers_js_1 = require_ciphers();
626
+ var is_key_like_js_1 = require_is_key_like();
627
+ function checkKeySize(key, alg) {
628
+ if (key.symmetricKeySize << 3 !== parseInt(alg.slice(1, 4), 10)) throw new TypeError(`Invalid key size for alg: ${alg}`);
629
+ }
630
+ function ensureKeyObject(key, alg, usage) {
631
+ if ((0, is_key_object_js_1.default)(key)) return key;
632
+ if (key instanceof Uint8Array) return (0, node_crypto_1.createSecretKey)(key);
633
+ if ((0, webcrypto_js_1.isCryptoKey)(key)) {
634
+ (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, usage);
635
+ return node_crypto_1.KeyObject.from(key);
636
+ }
637
+ throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, "Uint8Array"));
638
+ }
639
+ var wrap = (alg, key, cek) => {
640
+ const algorithm = `aes${parseInt(alg.slice(1, 4), 10)}-wrap`;
641
+ if (!(0, ciphers_js_1.default)(algorithm)) throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
642
+ const keyObject = ensureKeyObject(key, alg, "wrapKey");
643
+ checkKeySize(keyObject, alg);
644
+ const cipher = (0, node_crypto_1.createCipheriv)(algorithm, keyObject, node_buffer_1.Buffer.alloc(8, 166));
645
+ return (0, buffer_utils_js_1.concat)(cipher.update(cek), cipher.final());
646
+ };
647
+ exports.wrap = wrap;
648
+ var unwrap = (alg, key, encryptedKey) => {
649
+ const algorithm = `aes${parseInt(alg.slice(1, 4), 10)}-wrap`;
650
+ if (!(0, ciphers_js_1.default)(algorithm)) throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
651
+ const keyObject = ensureKeyObject(key, alg, "unwrapKey");
652
+ checkKeySize(keyObject, alg);
653
+ const cipher = (0, node_crypto_1.createDecipheriv)(algorithm, keyObject, node_buffer_1.Buffer.alloc(8, 166));
654
+ return (0, buffer_utils_js_1.concat)(cipher.update(encryptedKey), cipher.final());
655
+ };
656
+ exports.unwrap = unwrap;
657
+ }));
658
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/is_jwk.js
659
+ var require_is_jwk = /* @__PURE__ */ __commonJSMin(((exports) => {
660
+ Object.defineProperty(exports, "__esModule", { value: true });
661
+ exports.isJWK = isJWK;
662
+ exports.isPrivateJWK = isPrivateJWK;
663
+ exports.isPublicJWK = isPublicJWK;
664
+ exports.isSecretJWK = isSecretJWK;
665
+ var is_object_js_1 = require_is_object();
666
+ function isJWK(key) {
667
+ return (0, is_object_js_1.default)(key) && typeof key.kty === "string";
668
+ }
669
+ function isPrivateJWK(key) {
670
+ return key.kty !== "oct" && typeof key.d === "string";
671
+ }
672
+ function isPublicJWK(key) {
673
+ return key.kty !== "oct" && typeof key.d === "undefined";
674
+ }
675
+ function isSecretJWK(key) {
676
+ return isJWK(key) && key.kty === "oct" && typeof key.k === "string";
677
+ }
678
+ }));
679
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/get_named_curve.js
680
+ var require_get_named_curve = /* @__PURE__ */ __commonJSMin(((exports) => {
681
+ Object.defineProperty(exports, "__esModule", { value: true });
682
+ exports.weakMap = void 0;
683
+ var node_crypto_1 = __require("node:crypto");
684
+ var errors_js_1 = require_errors();
685
+ var webcrypto_js_1 = require_webcrypto();
686
+ var is_key_object_js_1 = require_is_key_object();
687
+ var invalid_key_input_js_1 = require_invalid_key_input();
688
+ var is_key_like_js_1 = require_is_key_like();
689
+ var is_jwk_js_1 = require_is_jwk();
690
+ exports.weakMap = /* @__PURE__ */ new WeakMap();
691
+ var namedCurveToJOSE = (namedCurve) => {
692
+ switch (namedCurve) {
693
+ case "prime256v1": return "P-256";
694
+ case "secp384r1": return "P-384";
695
+ case "secp521r1": return "P-521";
696
+ case "secp256k1": return "secp256k1";
697
+ default: throw new errors_js_1.JOSENotSupported("Unsupported key curve for this operation");
698
+ }
699
+ };
700
+ var getNamedCurve = (kee, raw) => {
701
+ let key;
702
+ if ((0, webcrypto_js_1.isCryptoKey)(kee)) key = node_crypto_1.KeyObject.from(kee);
703
+ else if ((0, is_key_object_js_1.default)(kee)) key = kee;
704
+ else if ((0, is_jwk_js_1.isJWK)(kee)) return kee.crv;
705
+ else throw new TypeError((0, invalid_key_input_js_1.default)(kee, ...is_key_like_js_1.types));
706
+ if (key.type === "secret") throw new TypeError("only \"private\" or \"public\" type keys can be used for this operation");
707
+ switch (key.asymmetricKeyType) {
708
+ case "ed25519":
709
+ case "ed448": return `Ed${key.asymmetricKeyType.slice(2)}`;
710
+ case "x25519":
711
+ case "x448": return `X${key.asymmetricKeyType.slice(1)}`;
712
+ case "ec": {
713
+ const namedCurve = key.asymmetricKeyDetails.namedCurve;
714
+ if (raw) return namedCurve;
715
+ return namedCurveToJOSE(namedCurve);
716
+ }
717
+ default: throw new TypeError("Invalid asymmetric key type for this operation");
718
+ }
719
+ };
720
+ exports.default = getNamedCurve;
721
+ }));
722
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/ecdhes.js
723
+ var require_ecdhes = /* @__PURE__ */ __commonJSMin(((exports) => {
724
+ Object.defineProperty(exports, "__esModule", { value: true });
725
+ exports.ecdhAllowed = void 0;
726
+ exports.deriveKey = deriveKey;
727
+ exports.generateEpk = generateEpk;
728
+ var node_crypto_1 = __require("node:crypto");
729
+ var node_util_1 = __require("node:util");
730
+ var get_named_curve_js_1 = require_get_named_curve();
731
+ var buffer_utils_js_1 = require_buffer_utils();
732
+ var errors_js_1 = require_errors();
733
+ var webcrypto_js_1 = require_webcrypto();
734
+ var crypto_key_js_1 = require_crypto_key();
735
+ var is_key_object_js_1 = require_is_key_object();
736
+ var invalid_key_input_js_1 = require_invalid_key_input();
737
+ var is_key_like_js_1 = require_is_key_like();
738
+ var generateKeyPair = (0, node_util_1.promisify)(node_crypto_1.generateKeyPair);
739
+ async function deriveKey(publicKee, privateKee, algorithm, keyLength, apu = /* @__PURE__ */ new Uint8Array(0), apv = /* @__PURE__ */ new Uint8Array(0)) {
740
+ let publicKey;
741
+ if ((0, webcrypto_js_1.isCryptoKey)(publicKee)) {
742
+ (0, crypto_key_js_1.checkEncCryptoKey)(publicKee, "ECDH");
743
+ publicKey = node_crypto_1.KeyObject.from(publicKee);
744
+ } else if ((0, is_key_object_js_1.default)(publicKee)) publicKey = publicKee;
745
+ else throw new TypeError((0, invalid_key_input_js_1.default)(publicKee, ...is_key_like_js_1.types));
746
+ let privateKey;
747
+ if ((0, webcrypto_js_1.isCryptoKey)(privateKee)) {
748
+ (0, crypto_key_js_1.checkEncCryptoKey)(privateKee, "ECDH", "deriveBits");
749
+ privateKey = node_crypto_1.KeyObject.from(privateKee);
750
+ } else if ((0, is_key_object_js_1.default)(privateKee)) privateKey = privateKee;
751
+ else throw new TypeError((0, invalid_key_input_js_1.default)(privateKee, ...is_key_like_js_1.types));
752
+ const value = (0, buffer_utils_js_1.concat)((0, buffer_utils_js_1.lengthAndInput)(buffer_utils_js_1.encoder.encode(algorithm)), (0, buffer_utils_js_1.lengthAndInput)(apu), (0, buffer_utils_js_1.lengthAndInput)(apv), (0, buffer_utils_js_1.uint32be)(keyLength));
753
+ const sharedSecret = (0, node_crypto_1.diffieHellman)({
754
+ privateKey,
755
+ publicKey
756
+ });
757
+ return (0, buffer_utils_js_1.concatKdf)(sharedSecret, keyLength, value);
758
+ }
759
+ async function generateEpk(kee) {
760
+ let key;
761
+ if ((0, webcrypto_js_1.isCryptoKey)(kee)) key = node_crypto_1.KeyObject.from(kee);
762
+ else if ((0, is_key_object_js_1.default)(kee)) key = kee;
763
+ else throw new TypeError((0, invalid_key_input_js_1.default)(kee, ...is_key_like_js_1.types));
764
+ switch (key.asymmetricKeyType) {
765
+ case "x25519": return generateKeyPair("x25519");
766
+ case "x448": return generateKeyPair("x448");
767
+ case "ec": return generateKeyPair("ec", { namedCurve: (0, get_named_curve_js_1.default)(key) });
768
+ default: throw new errors_js_1.JOSENotSupported("Invalid or unsupported EPK");
769
+ }
770
+ }
771
+ var ecdhAllowed = (key) => [
772
+ "P-256",
773
+ "P-384",
774
+ "P-521",
775
+ "X25519",
776
+ "X448"
777
+ ].includes((0, get_named_curve_js_1.default)(key));
778
+ exports.ecdhAllowed = ecdhAllowed;
779
+ }));
780
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/check_p2s.js
781
+ var require_check_p2s = /* @__PURE__ */ __commonJSMin(((exports) => {
782
+ Object.defineProperty(exports, "__esModule", { value: true });
783
+ exports.default = checkP2s;
784
+ var errors_js_1 = require_errors();
785
+ function checkP2s(p2s) {
786
+ if (!(p2s instanceof Uint8Array) || p2s.length < 8) throw new errors_js_1.JWEInvalid("PBES2 Salt Input must be 8 or more octets");
787
+ }
788
+ }));
789
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/pbes2kw.js
790
+ var require_pbes2kw = /* @__PURE__ */ __commonJSMin(((exports) => {
791
+ Object.defineProperty(exports, "__esModule", { value: true });
792
+ exports.decrypt = exports.encrypt = void 0;
793
+ var node_util_1 = __require("node:util");
794
+ var node_crypto_1 = __require("node:crypto");
795
+ var random_js_1 = require_random();
796
+ var buffer_utils_js_1 = require_buffer_utils();
797
+ var base64url_js_1 = require_base64url$1();
798
+ var aeskw_js_1 = require_aeskw();
799
+ var check_p2s_js_1 = require_check_p2s();
800
+ var webcrypto_js_1 = require_webcrypto();
801
+ var crypto_key_js_1 = require_crypto_key();
802
+ var is_key_object_js_1 = require_is_key_object();
803
+ var invalid_key_input_js_1 = require_invalid_key_input();
804
+ var is_key_like_js_1 = require_is_key_like();
805
+ var pbkdf2 = (0, node_util_1.promisify)(node_crypto_1.pbkdf2);
806
+ function getPassword(key, alg) {
807
+ if ((0, is_key_object_js_1.default)(key)) return key.export();
808
+ if (key instanceof Uint8Array) return key;
809
+ if ((0, webcrypto_js_1.isCryptoKey)(key)) {
810
+ (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, "deriveBits", "deriveKey");
811
+ return node_crypto_1.KeyObject.from(key).export();
812
+ }
813
+ throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, "Uint8Array"));
814
+ }
815
+ var encrypt = async (alg, key, cek, p2c = 2048, p2s = (0, random_js_1.default)(/* @__PURE__ */ new Uint8Array(16))) => {
816
+ (0, check_p2s_js_1.default)(p2s);
817
+ const salt = (0, buffer_utils_js_1.p2s)(alg, p2s);
818
+ const keylen = parseInt(alg.slice(13, 16), 10) >> 3;
819
+ const derivedKey = await pbkdf2(getPassword(key, alg), salt, p2c, keylen, `sha${alg.slice(8, 11)}`);
820
+ return {
821
+ encryptedKey: await (0, aeskw_js_1.wrap)(alg.slice(-6), derivedKey, cek),
822
+ p2c,
823
+ p2s: (0, base64url_js_1.encode)(p2s)
824
+ };
825
+ };
826
+ exports.encrypt = encrypt;
827
+ var decrypt = async (alg, key, encryptedKey, p2c, p2s) => {
828
+ (0, check_p2s_js_1.default)(p2s);
829
+ const salt = (0, buffer_utils_js_1.p2s)(alg, p2s);
830
+ const keylen = parseInt(alg.slice(13, 16), 10) >> 3;
831
+ const derivedKey = await pbkdf2(getPassword(key, alg), salt, p2c, keylen, `sha${alg.slice(8, 11)}`);
832
+ return (0, aeskw_js_1.unwrap)(alg.slice(-6), derivedKey, encryptedKey);
833
+ };
834
+ exports.decrypt = decrypt;
835
+ }));
836
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/check_key_length.js
837
+ var require_check_key_length = /* @__PURE__ */ __commonJSMin(((exports) => {
838
+ Object.defineProperty(exports, "__esModule", { value: true });
839
+ var node_crypto_1 = __require("node:crypto");
840
+ exports.default = (key, alg) => {
841
+ let modulusLength;
842
+ try {
843
+ if (key instanceof node_crypto_1.KeyObject) modulusLength = key.asymmetricKeyDetails?.modulusLength;
844
+ else modulusLength = Buffer.from(key.n, "base64url").byteLength << 3;
845
+ } catch {}
846
+ if (typeof modulusLength !== "number" || modulusLength < 2048) throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
847
+ };
848
+ }));
849
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/rsaes.js
850
+ var require_rsaes = /* @__PURE__ */ __commonJSMin(((exports) => {
851
+ Object.defineProperty(exports, "__esModule", { value: true });
852
+ exports.decrypt = exports.encrypt = void 0;
853
+ var node_crypto_1 = __require("node:crypto");
854
+ var node_util_1 = __require("node:util");
855
+ var check_key_length_js_1 = require_check_key_length();
856
+ var webcrypto_js_1 = require_webcrypto();
857
+ var crypto_key_js_1 = require_crypto_key();
858
+ var is_key_object_js_1 = require_is_key_object();
859
+ var invalid_key_input_js_1 = require_invalid_key_input();
860
+ var is_key_like_js_1 = require_is_key_like();
861
+ var checkKey = (key, alg) => {
862
+ if (key.asymmetricKeyType !== "rsa") throw new TypeError("Invalid key for this operation, its asymmetricKeyType must be rsa");
863
+ (0, check_key_length_js_1.default)(key, alg);
864
+ };
865
+ var RSA1_5 = (0, node_util_1.deprecate)(() => node_crypto_1.constants.RSA_PKCS1_PADDING, "The RSA1_5 \"alg\" (JWE Algorithm) is deprecated and will be removed in the next major revision.");
866
+ var resolvePadding = (alg) => {
867
+ switch (alg) {
868
+ case "RSA-OAEP":
869
+ case "RSA-OAEP-256":
870
+ case "RSA-OAEP-384":
871
+ case "RSA-OAEP-512": return node_crypto_1.constants.RSA_PKCS1_OAEP_PADDING;
872
+ case "RSA1_5": return RSA1_5();
873
+ default: return;
874
+ }
875
+ };
876
+ var resolveOaepHash = (alg) => {
877
+ switch (alg) {
878
+ case "RSA-OAEP": return "sha1";
879
+ case "RSA-OAEP-256": return "sha256";
880
+ case "RSA-OAEP-384": return "sha384";
881
+ case "RSA-OAEP-512": return "sha512";
882
+ default: return;
883
+ }
884
+ };
885
+ function ensureKeyObject(key, alg, ...usages) {
886
+ if ((0, is_key_object_js_1.default)(key)) return key;
887
+ if ((0, webcrypto_js_1.isCryptoKey)(key)) {
888
+ (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, ...usages);
889
+ return node_crypto_1.KeyObject.from(key);
890
+ }
891
+ throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
892
+ }
893
+ var encrypt = (alg, key, cek) => {
894
+ const padding = resolvePadding(alg);
895
+ const oaepHash = resolveOaepHash(alg);
896
+ const keyObject = ensureKeyObject(key, alg, "wrapKey", "encrypt");
897
+ checkKey(keyObject, alg);
898
+ return (0, node_crypto_1.publicEncrypt)({
899
+ key: keyObject,
900
+ oaepHash,
901
+ padding
902
+ }, cek);
903
+ };
904
+ exports.encrypt = encrypt;
905
+ var decrypt = (alg, key, encryptedKey) => {
906
+ const padding = resolvePadding(alg);
907
+ const oaepHash = resolveOaepHash(alg);
908
+ const keyObject = ensureKeyObject(key, alg, "unwrapKey", "decrypt");
909
+ checkKey(keyObject, alg);
910
+ return (0, node_crypto_1.privateDecrypt)({
911
+ key: keyObject,
912
+ oaepHash,
913
+ padding
914
+ }, encryptedKey);
915
+ };
916
+ exports.decrypt = decrypt;
917
+ }));
918
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/normalize_key.js
919
+ var require_normalize_key = /* @__PURE__ */ __commonJSMin(((exports) => {
920
+ Object.defineProperty(exports, "__esModule", { value: true });
921
+ exports.default = {};
922
+ }));
923
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/cek.js
924
+ var require_cek = /* @__PURE__ */ __commonJSMin(((exports) => {
925
+ Object.defineProperty(exports, "__esModule", { value: true });
926
+ exports.bitLength = bitLength;
927
+ var errors_js_1 = require_errors();
928
+ var random_js_1 = require_random();
929
+ function bitLength(alg) {
930
+ switch (alg) {
931
+ case "A128GCM": return 128;
932
+ case "A192GCM": return 192;
933
+ case "A256GCM":
934
+ case "A128CBC-HS256": return 256;
935
+ case "A192CBC-HS384": return 384;
936
+ case "A256CBC-HS512": return 512;
937
+ default: throw new errors_js_1.JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
938
+ }
939
+ }
940
+ exports.default = (alg) => (0, random_js_1.default)(new Uint8Array(bitLength(alg) >> 3));
941
+ }));
942
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/asn1.js
943
+ var require_asn1 = /* @__PURE__ */ __commonJSMin(((exports) => {
944
+ Object.defineProperty(exports, "__esModule", { value: true });
945
+ exports.fromX509 = exports.fromSPKI = exports.fromPKCS8 = exports.toPKCS8 = exports.toSPKI = void 0;
946
+ var node_crypto_1 = __require("node:crypto");
947
+ var node_buffer_1 = __require("node:buffer");
948
+ var webcrypto_js_1 = require_webcrypto();
949
+ var is_key_object_js_1 = require_is_key_object();
950
+ var invalid_key_input_js_1 = require_invalid_key_input();
951
+ var is_key_like_js_1 = require_is_key_like();
952
+ var genericExport = (keyType, keyFormat, key) => {
953
+ let keyObject;
954
+ if ((0, webcrypto_js_1.isCryptoKey)(key)) {
955
+ if (!key.extractable) throw new TypeError("CryptoKey is not extractable");
956
+ keyObject = node_crypto_1.KeyObject.from(key);
957
+ } else if ((0, is_key_object_js_1.default)(key)) keyObject = key;
958
+ else throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
959
+ if (keyObject.type !== keyType) throw new TypeError(`key is not a ${keyType} key`);
960
+ return keyObject.export({
961
+ format: "pem",
962
+ type: keyFormat
963
+ });
964
+ };
965
+ var toSPKI = (key) => {
966
+ return genericExport("public", "spki", key);
967
+ };
968
+ exports.toSPKI = toSPKI;
969
+ var toPKCS8 = (key) => {
970
+ return genericExport("private", "pkcs8", key);
971
+ };
972
+ exports.toPKCS8 = toPKCS8;
973
+ var fromPKCS8 = (pem) => (0, node_crypto_1.createPrivateKey)({
974
+ key: node_buffer_1.Buffer.from(pem.replace(/(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g, ""), "base64"),
975
+ type: "pkcs8",
976
+ format: "der"
977
+ });
978
+ exports.fromPKCS8 = fromPKCS8;
979
+ var fromSPKI = (pem) => (0, node_crypto_1.createPublicKey)({
980
+ key: node_buffer_1.Buffer.from(pem.replace(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, ""), "base64"),
981
+ type: "spki",
982
+ format: "der"
983
+ });
984
+ exports.fromSPKI = fromSPKI;
985
+ var fromX509 = (pem) => (0, node_crypto_1.createPublicKey)({
986
+ key: pem,
987
+ type: "spki",
988
+ format: "pem"
989
+ });
990
+ exports.fromX509 = fromX509;
991
+ }));
992
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/jwk_to_key.js
993
+ var require_jwk_to_key = /* @__PURE__ */ __commonJSMin(((exports) => {
994
+ Object.defineProperty(exports, "__esModule", { value: true });
995
+ var node_crypto_1 = __require("node:crypto");
996
+ var parse = (key) => {
997
+ if (key.d) return (0, node_crypto_1.createPrivateKey)({
998
+ format: "jwk",
999
+ key
1000
+ });
1001
+ return (0, node_crypto_1.createPublicKey)({
1002
+ format: "jwk",
1003
+ key
1004
+ });
1005
+ };
1006
+ exports.default = parse;
1007
+ }));
1008
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/key/import.js
1009
+ var require_import = /* @__PURE__ */ __commonJSMin(((exports) => {
1010
+ Object.defineProperty(exports, "__esModule", { value: true });
1011
+ exports.importSPKI = importSPKI;
1012
+ exports.importX509 = importX509;
1013
+ exports.importPKCS8 = importPKCS8;
1014
+ exports.importJWK = importJWK;
1015
+ var base64url_js_1 = require_base64url$1();
1016
+ var asn1_js_1 = require_asn1();
1017
+ var jwk_to_key_js_1 = require_jwk_to_key();
1018
+ var errors_js_1 = require_errors();
1019
+ var is_object_js_1 = require_is_object();
1020
+ async function importSPKI(spki, alg, options) {
1021
+ if (typeof spki !== "string" || spki.indexOf("-----BEGIN PUBLIC KEY-----") !== 0) throw new TypeError("\"spki\" must be SPKI formatted string");
1022
+ return (0, asn1_js_1.fromSPKI)(spki, alg, options);
1023
+ }
1024
+ async function importX509(x509, alg, options) {
1025
+ if (typeof x509 !== "string" || x509.indexOf("-----BEGIN CERTIFICATE-----") !== 0) throw new TypeError("\"x509\" must be X.509 formatted string");
1026
+ return (0, asn1_js_1.fromX509)(x509, alg, options);
1027
+ }
1028
+ async function importPKCS8(pkcs8, alg, options) {
1029
+ if (typeof pkcs8 !== "string" || pkcs8.indexOf("-----BEGIN PRIVATE KEY-----") !== 0) throw new TypeError("\"pkcs8\" must be PKCS#8 formatted string");
1030
+ return (0, asn1_js_1.fromPKCS8)(pkcs8, alg, options);
1031
+ }
1032
+ async function importJWK(jwk, alg) {
1033
+ if (!(0, is_object_js_1.default)(jwk)) throw new TypeError("JWK must be an object");
1034
+ alg ||= jwk.alg;
1035
+ switch (jwk.kty) {
1036
+ case "oct":
1037
+ if (typeof jwk.k !== "string" || !jwk.k) throw new TypeError("missing \"k\" (Key Value) Parameter value");
1038
+ return (0, base64url_js_1.decode)(jwk.k);
1039
+ case "RSA": if ("oth" in jwk && jwk.oth !== void 0) throw new errors_js_1.JOSENotSupported("RSA JWK \"oth\" (Other Primes Info) Parameter value is not supported");
1040
+ case "EC":
1041
+ case "OKP": return (0, jwk_to_key_js_1.default)({
1042
+ ...jwk,
1043
+ alg
1044
+ });
1045
+ default: throw new errors_js_1.JOSENotSupported("Unsupported \"kty\" (Key Type) Parameter value");
1046
+ }
1047
+ }
1048
+ }));
1049
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/check_key_type.js
1050
+ var require_check_key_type = /* @__PURE__ */ __commonJSMin(((exports) => {
1051
+ Object.defineProperty(exports, "__esModule", { value: true });
1052
+ exports.checkKeyTypeWithJwk = void 0;
1053
+ var invalid_key_input_js_1 = require_invalid_key_input();
1054
+ var is_key_like_js_1 = require_is_key_like();
1055
+ var jwk = require_is_jwk();
1056
+ var tag = (key) => key?.[Symbol.toStringTag];
1057
+ var jwkMatchesOp = (alg, key, usage) => {
1058
+ if (key.use !== void 0 && key.use !== "sig") throw new TypeError("Invalid key for this operation, when present its use must be sig");
1059
+ if (key.key_ops !== void 0 && key.key_ops.includes?.(usage) !== true) throw new TypeError(`Invalid key for this operation, when present its key_ops must include ${usage}`);
1060
+ if (key.alg !== void 0 && key.alg !== alg) throw new TypeError(`Invalid key for this operation, when present its alg must be ${alg}`);
1061
+ return true;
1062
+ };
1063
+ var symmetricTypeCheck = (alg, key, usage, allowJwk) => {
1064
+ if (key instanceof Uint8Array) return;
1065
+ if (allowJwk && jwk.isJWK(key)) {
1066
+ if (jwk.isSecretJWK(key) && jwkMatchesOp(alg, key, usage)) return;
1067
+ throw new TypeError(`JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present`);
1068
+ }
1069
+ if (!(0, is_key_like_js_1.default)(key)) throw new TypeError((0, invalid_key_input_js_1.withAlg)(alg, key, ...is_key_like_js_1.types, "Uint8Array", allowJwk ? "JSON Web Key" : null));
1070
+ if (key.type !== "secret") throw new TypeError(`${tag(key)} instances for symmetric algorithms must be of type "secret"`);
1071
+ };
1072
+ var asymmetricTypeCheck = (alg, key, usage, allowJwk) => {
1073
+ if (allowJwk && jwk.isJWK(key)) switch (usage) {
1074
+ case "sign":
1075
+ if (jwk.isPrivateJWK(key) && jwkMatchesOp(alg, key, usage)) return;
1076
+ throw new TypeError(`JSON Web Key for this operation be a private JWK`);
1077
+ case "verify":
1078
+ if (jwk.isPublicJWK(key) && jwkMatchesOp(alg, key, usage)) return;
1079
+ throw new TypeError(`JSON Web Key for this operation be a public JWK`);
1080
+ }
1081
+ if (!(0, is_key_like_js_1.default)(key)) throw new TypeError((0, invalid_key_input_js_1.withAlg)(alg, key, ...is_key_like_js_1.types, allowJwk ? "JSON Web Key" : null));
1082
+ if (key.type === "secret") throw new TypeError(`${tag(key)} instances for asymmetric algorithms must not be of type "secret"`);
1083
+ if (usage === "sign" && key.type === "public") throw new TypeError(`${tag(key)} instances for asymmetric algorithm signing must be of type "private"`);
1084
+ if (usage === "decrypt" && key.type === "public") throw new TypeError(`${tag(key)} instances for asymmetric algorithm decryption must be of type "private"`);
1085
+ if (key.algorithm && usage === "verify" && key.type === "private") throw new TypeError(`${tag(key)} instances for asymmetric algorithm verifying must be of type "public"`);
1086
+ if (key.algorithm && usage === "encrypt" && key.type === "private") throw new TypeError(`${tag(key)} instances for asymmetric algorithm encryption must be of type "public"`);
1087
+ };
1088
+ function checkKeyType(allowJwk, alg, key, usage) {
1089
+ if (alg.startsWith("HS") || alg === "dir" || alg.startsWith("PBES2") || /^A\d{3}(?:GCM)?KW$/.test(alg)) symmetricTypeCheck(alg, key, usage, allowJwk);
1090
+ else asymmetricTypeCheck(alg, key, usage, allowJwk);
1091
+ }
1092
+ exports.default = checkKeyType.bind(void 0, false);
1093
+ exports.checkKeyTypeWithJwk = checkKeyType.bind(void 0, true);
1094
+ }));
1095
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/encrypt.js
1096
+ var require_encrypt$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
1097
+ Object.defineProperty(exports, "__esModule", { value: true });
1098
+ var node_crypto_1 = __require("node:crypto");
1099
+ var check_iv_length_js_1 = require_check_iv_length();
1100
+ var check_cek_length_js_1 = require_check_cek_length();
1101
+ var buffer_utils_js_1 = require_buffer_utils();
1102
+ var cbc_tag_js_1 = require_cbc_tag();
1103
+ var webcrypto_js_1 = require_webcrypto();
1104
+ var crypto_key_js_1 = require_crypto_key();
1105
+ var is_key_object_js_1 = require_is_key_object();
1106
+ var invalid_key_input_js_1 = require_invalid_key_input();
1107
+ var iv_js_1 = require_iv();
1108
+ var errors_js_1 = require_errors();
1109
+ var ciphers_js_1 = require_ciphers();
1110
+ var is_key_like_js_1 = require_is_key_like();
1111
+ function cbcEncrypt(enc, plaintext, cek, iv, aad) {
1112
+ const keySize = parseInt(enc.slice(1, 4), 10);
1113
+ if ((0, is_key_object_js_1.default)(cek)) cek = cek.export();
1114
+ const encKey = cek.subarray(keySize >> 3);
1115
+ const macKey = cek.subarray(0, keySize >> 3);
1116
+ const algorithm = `aes-${keySize}-cbc`;
1117
+ if (!(0, ciphers_js_1.default)(algorithm)) throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
1118
+ const cipher = (0, node_crypto_1.createCipheriv)(algorithm, encKey, iv);
1119
+ const ciphertext = (0, buffer_utils_js_1.concat)(cipher.update(plaintext), cipher.final());
1120
+ const macSize = parseInt(enc.slice(-3), 10);
1121
+ return {
1122
+ ciphertext,
1123
+ tag: (0, cbc_tag_js_1.default)(aad, iv, ciphertext, macSize, macKey, keySize),
1124
+ iv
1125
+ };
1126
+ }
1127
+ function gcmEncrypt(enc, plaintext, cek, iv, aad) {
1128
+ const algorithm = `aes-${parseInt(enc.slice(1, 4), 10)}-gcm`;
1129
+ if (!(0, ciphers_js_1.default)(algorithm)) throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
1130
+ const cipher = (0, node_crypto_1.createCipheriv)(algorithm, cek, iv, { authTagLength: 16 });
1131
+ if (aad.byteLength) cipher.setAAD(aad, { plaintextLength: plaintext.length });
1132
+ const ciphertext = cipher.update(plaintext);
1133
+ cipher.final();
1134
+ return {
1135
+ ciphertext,
1136
+ tag: cipher.getAuthTag(),
1137
+ iv
1138
+ };
1139
+ }
1140
+ var encrypt = (enc, plaintext, cek, iv, aad) => {
1141
+ let key;
1142
+ if ((0, webcrypto_js_1.isCryptoKey)(cek)) {
1143
+ (0, crypto_key_js_1.checkEncCryptoKey)(cek, enc, "encrypt");
1144
+ key = node_crypto_1.KeyObject.from(cek);
1145
+ } else if (cek instanceof Uint8Array || (0, is_key_object_js_1.default)(cek)) key = cek;
1146
+ else throw new TypeError((0, invalid_key_input_js_1.default)(cek, ...is_key_like_js_1.types, "Uint8Array"));
1147
+ (0, check_cek_length_js_1.default)(enc, key);
1148
+ if (iv) (0, check_iv_length_js_1.default)(enc, iv);
1149
+ else iv = (0, iv_js_1.default)(enc);
1150
+ switch (enc) {
1151
+ case "A128CBC-HS256":
1152
+ case "A192CBC-HS384":
1153
+ case "A256CBC-HS512": return cbcEncrypt(enc, plaintext, key, iv, aad);
1154
+ case "A128GCM":
1155
+ case "A192GCM":
1156
+ case "A256GCM": return gcmEncrypt(enc, plaintext, key, iv, aad);
1157
+ default: throw new errors_js_1.JOSENotSupported("Unsupported JWE Content Encryption Algorithm");
1158
+ }
1159
+ };
1160
+ exports.default = encrypt;
1161
+ }));
1162
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/aesgcmkw.js
1163
+ var require_aesgcmkw = /* @__PURE__ */ __commonJSMin(((exports) => {
1164
+ Object.defineProperty(exports, "__esModule", { value: true });
1165
+ exports.wrap = wrap;
1166
+ exports.unwrap = unwrap;
1167
+ var encrypt_js_1 = require_encrypt$4();
1168
+ var decrypt_js_1 = require_decrypt$4();
1169
+ var base64url_js_1 = require_base64url$1();
1170
+ async function wrap(alg, key, cek, iv) {
1171
+ const jweAlgorithm = alg.slice(0, 7);
1172
+ const wrapped = await (0, encrypt_js_1.default)(jweAlgorithm, cek, key, iv, /* @__PURE__ */ new Uint8Array(0));
1173
+ return {
1174
+ encryptedKey: wrapped.ciphertext,
1175
+ iv: (0, base64url_js_1.encode)(wrapped.iv),
1176
+ tag: (0, base64url_js_1.encode)(wrapped.tag)
1177
+ };
1178
+ }
1179
+ async function unwrap(alg, key, encryptedKey, iv, tag) {
1180
+ const jweAlgorithm = alg.slice(0, 7);
1181
+ return (0, decrypt_js_1.default)(jweAlgorithm, key, encryptedKey, iv, tag, /* @__PURE__ */ new Uint8Array(0));
1182
+ }
1183
+ }));
1184
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/decrypt_key_management.js
1185
+ var require_decrypt_key_management = /* @__PURE__ */ __commonJSMin(((exports) => {
1186
+ Object.defineProperty(exports, "__esModule", { value: true });
1187
+ var aeskw_js_1 = require_aeskw();
1188
+ var ECDH = require_ecdhes();
1189
+ var pbes2kw_js_1 = require_pbes2kw();
1190
+ var rsaes_js_1 = require_rsaes();
1191
+ var base64url_js_1 = require_base64url$1();
1192
+ var normalize_key_js_1 = require_normalize_key();
1193
+ var errors_js_1 = require_errors();
1194
+ var cek_js_1 = require_cek();
1195
+ var import_js_1 = require_import();
1196
+ var check_key_type_js_1 = require_check_key_type();
1197
+ var is_object_js_1 = require_is_object();
1198
+ var aesgcmkw_js_1 = require_aesgcmkw();
1199
+ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options) {
1200
+ (0, check_key_type_js_1.default)(alg, key, "decrypt");
1201
+ key = await normalize_key_js_1.default.normalizePrivateKey?.(key, alg) || key;
1202
+ switch (alg) {
1203
+ case "dir":
1204
+ if (encryptedKey !== void 0) throw new errors_js_1.JWEInvalid("Encountered unexpected JWE Encrypted Key");
1205
+ return key;
1206
+ case "ECDH-ES": if (encryptedKey !== void 0) throw new errors_js_1.JWEInvalid("Encountered unexpected JWE Encrypted Key");
1207
+ case "ECDH-ES+A128KW":
1208
+ case "ECDH-ES+A192KW":
1209
+ case "ECDH-ES+A256KW": {
1210
+ if (!(0, is_object_js_1.default)(joseHeader.epk)) throw new errors_js_1.JWEInvalid(`JOSE Header "epk" (Ephemeral Public Key) missing or invalid`);
1211
+ if (!ECDH.ecdhAllowed(key)) throw new errors_js_1.JOSENotSupported("ECDH with the provided key is not allowed or not supported by your javascript runtime");
1212
+ const epk = await (0, import_js_1.importJWK)(joseHeader.epk, alg);
1213
+ let partyUInfo;
1214
+ let partyVInfo;
1215
+ if (joseHeader.apu !== void 0) {
1216
+ if (typeof joseHeader.apu !== "string") throw new errors_js_1.JWEInvalid(`JOSE Header "apu" (Agreement PartyUInfo) invalid`);
1217
+ try {
1218
+ partyUInfo = (0, base64url_js_1.decode)(joseHeader.apu);
1219
+ } catch {
1220
+ throw new errors_js_1.JWEInvalid("Failed to base64url decode the apu");
1221
+ }
1222
+ }
1223
+ if (joseHeader.apv !== void 0) {
1224
+ if (typeof joseHeader.apv !== "string") throw new errors_js_1.JWEInvalid(`JOSE Header "apv" (Agreement PartyVInfo) invalid`);
1225
+ try {
1226
+ partyVInfo = (0, base64url_js_1.decode)(joseHeader.apv);
1227
+ } catch {
1228
+ throw new errors_js_1.JWEInvalid("Failed to base64url decode the apv");
1229
+ }
1230
+ }
1231
+ const sharedSecret = await ECDH.deriveKey(epk, key, alg === "ECDH-ES" ? joseHeader.enc : alg, alg === "ECDH-ES" ? (0, cek_js_1.bitLength)(joseHeader.enc) : parseInt(alg.slice(-5, -2), 10), partyUInfo, partyVInfo);
1232
+ if (alg === "ECDH-ES") return sharedSecret;
1233
+ if (encryptedKey === void 0) throw new errors_js_1.JWEInvalid("JWE Encrypted Key missing");
1234
+ return (0, aeskw_js_1.unwrap)(alg.slice(-6), sharedSecret, encryptedKey);
1235
+ }
1236
+ case "RSA1_5":
1237
+ case "RSA-OAEP":
1238
+ case "RSA-OAEP-256":
1239
+ case "RSA-OAEP-384":
1240
+ case "RSA-OAEP-512":
1241
+ if (encryptedKey === void 0) throw new errors_js_1.JWEInvalid("JWE Encrypted Key missing");
1242
+ return (0, rsaes_js_1.decrypt)(alg, key, encryptedKey);
1243
+ case "PBES2-HS256+A128KW":
1244
+ case "PBES2-HS384+A192KW":
1245
+ case "PBES2-HS512+A256KW": {
1246
+ if (encryptedKey === void 0) throw new errors_js_1.JWEInvalid("JWE Encrypted Key missing");
1247
+ if (typeof joseHeader.p2c !== "number") throw new errors_js_1.JWEInvalid(`JOSE Header "p2c" (PBES2 Count) missing or invalid`);
1248
+ const p2cLimit = options?.maxPBES2Count || 1e4;
1249
+ if (joseHeader.p2c > p2cLimit) throw new errors_js_1.JWEInvalid(`JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds`);
1250
+ if (typeof joseHeader.p2s !== "string") throw new errors_js_1.JWEInvalid(`JOSE Header "p2s" (PBES2 Salt) missing or invalid`);
1251
+ let p2s;
1252
+ try {
1253
+ p2s = (0, base64url_js_1.decode)(joseHeader.p2s);
1254
+ } catch {
1255
+ throw new errors_js_1.JWEInvalid("Failed to base64url decode the p2s");
1256
+ }
1257
+ return (0, pbes2kw_js_1.decrypt)(alg, key, encryptedKey, joseHeader.p2c, p2s);
1258
+ }
1259
+ case "A128KW":
1260
+ case "A192KW":
1261
+ case "A256KW":
1262
+ if (encryptedKey === void 0) throw new errors_js_1.JWEInvalid("JWE Encrypted Key missing");
1263
+ return (0, aeskw_js_1.unwrap)(alg, key, encryptedKey);
1264
+ case "A128GCMKW":
1265
+ case "A192GCMKW":
1266
+ case "A256GCMKW": {
1267
+ if (encryptedKey === void 0) throw new errors_js_1.JWEInvalid("JWE Encrypted Key missing");
1268
+ if (typeof joseHeader.iv !== "string") throw new errors_js_1.JWEInvalid(`JOSE Header "iv" (Initialization Vector) missing or invalid`);
1269
+ if (typeof joseHeader.tag !== "string") throw new errors_js_1.JWEInvalid(`JOSE Header "tag" (Authentication Tag) missing or invalid`);
1270
+ let iv;
1271
+ try {
1272
+ iv = (0, base64url_js_1.decode)(joseHeader.iv);
1273
+ } catch {
1274
+ throw new errors_js_1.JWEInvalid("Failed to base64url decode the iv");
1275
+ }
1276
+ let tag;
1277
+ try {
1278
+ tag = (0, base64url_js_1.decode)(joseHeader.tag);
1279
+ } catch {
1280
+ throw new errors_js_1.JWEInvalid("Failed to base64url decode the tag");
1281
+ }
1282
+ return (0, aesgcmkw_js_1.unwrap)(alg, key, encryptedKey, iv, tag);
1283
+ }
1284
+ default: throw new errors_js_1.JOSENotSupported("Invalid or unsupported \"alg\" (JWE Algorithm) header value");
1285
+ }
1286
+ }
1287
+ exports.default = decryptKeyManagement;
1288
+ }));
1289
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/validate_crit.js
1290
+ var require_validate_crit = /* @__PURE__ */ __commonJSMin(((exports) => {
1291
+ Object.defineProperty(exports, "__esModule", { value: true });
1292
+ var errors_js_1 = require_errors();
1293
+ function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
1294
+ if (joseHeader.crit !== void 0 && protectedHeader?.crit === void 0) throw new Err("\"crit\" (Critical) Header Parameter MUST be integrity protected");
1295
+ if (!protectedHeader || protectedHeader.crit === void 0) return /* @__PURE__ */ new Set();
1296
+ if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input !== "string" || input.length === 0)) throw new Err("\"crit\" (Critical) Header Parameter MUST be an array of non-empty strings when present");
1297
+ let recognized;
1298
+ if (recognizedOption !== void 0) recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
1299
+ else recognized = recognizedDefault;
1300
+ for (const parameter of protectedHeader.crit) {
1301
+ if (!recognized.has(parameter)) throw new errors_js_1.JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
1302
+ if (joseHeader[parameter] === void 0) throw new Err(`Extension Header Parameter "${parameter}" is missing`);
1303
+ if (recognized.get(parameter) && protectedHeader[parameter] === void 0) throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
1304
+ }
1305
+ return new Set(protectedHeader.crit);
1306
+ }
1307
+ exports.default = validateCrit;
1308
+ }));
1309
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/validate_algorithms.js
1310
+ var require_validate_algorithms = /* @__PURE__ */ __commonJSMin(((exports) => {
1311
+ Object.defineProperty(exports, "__esModule", { value: true });
1312
+ var validateAlgorithms = (option, algorithms) => {
1313
+ if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== "string"))) throw new TypeError(`"${option}" option must be an array of strings`);
1314
+ if (!algorithms) return;
1315
+ return new Set(algorithms);
1316
+ };
1317
+ exports.default = validateAlgorithms;
1318
+ }));
1319
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwe/flattened/decrypt.js
1320
+ var require_decrypt$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
1321
+ Object.defineProperty(exports, "__esModule", { value: true });
1322
+ exports.flattenedDecrypt = flattenedDecrypt;
1323
+ var base64url_js_1 = require_base64url$1();
1324
+ var decrypt_js_1 = require_decrypt$4();
1325
+ var errors_js_1 = require_errors();
1326
+ var is_disjoint_js_1 = require_is_disjoint();
1327
+ var is_object_js_1 = require_is_object();
1328
+ var decrypt_key_management_js_1 = require_decrypt_key_management();
1329
+ var buffer_utils_js_1 = require_buffer_utils();
1330
+ var cek_js_1 = require_cek();
1331
+ var validate_crit_js_1 = require_validate_crit();
1332
+ var validate_algorithms_js_1 = require_validate_algorithms();
1333
+ async function flattenedDecrypt(jwe, key, options) {
1334
+ if (!(0, is_object_js_1.default)(jwe)) throw new errors_js_1.JWEInvalid("Flattened JWE must be an object");
1335
+ if (jwe.protected === void 0 && jwe.header === void 0 && jwe.unprotected === void 0) throw new errors_js_1.JWEInvalid("JOSE Header missing");
1336
+ if (jwe.iv !== void 0 && typeof jwe.iv !== "string") throw new errors_js_1.JWEInvalid("JWE Initialization Vector incorrect type");
1337
+ if (typeof jwe.ciphertext !== "string") throw new errors_js_1.JWEInvalid("JWE Ciphertext missing or incorrect type");
1338
+ if (jwe.tag !== void 0 && typeof jwe.tag !== "string") throw new errors_js_1.JWEInvalid("JWE Authentication Tag incorrect type");
1339
+ if (jwe.protected !== void 0 && typeof jwe.protected !== "string") throw new errors_js_1.JWEInvalid("JWE Protected Header incorrect type");
1340
+ if (jwe.encrypted_key !== void 0 && typeof jwe.encrypted_key !== "string") throw new errors_js_1.JWEInvalid("JWE Encrypted Key incorrect type");
1341
+ if (jwe.aad !== void 0 && typeof jwe.aad !== "string") throw new errors_js_1.JWEInvalid("JWE AAD incorrect type");
1342
+ if (jwe.header !== void 0 && !(0, is_object_js_1.default)(jwe.header)) throw new errors_js_1.JWEInvalid("JWE Shared Unprotected Header incorrect type");
1343
+ if (jwe.unprotected !== void 0 && !(0, is_object_js_1.default)(jwe.unprotected)) throw new errors_js_1.JWEInvalid("JWE Per-Recipient Unprotected Header incorrect type");
1344
+ let parsedProt;
1345
+ if (jwe.protected) try {
1346
+ const protectedHeader = (0, base64url_js_1.decode)(jwe.protected);
1347
+ parsedProt = JSON.parse(buffer_utils_js_1.decoder.decode(protectedHeader));
1348
+ } catch {
1349
+ throw new errors_js_1.JWEInvalid("JWE Protected Header is invalid");
1350
+ }
1351
+ if (!(0, is_disjoint_js_1.default)(parsedProt, jwe.header, jwe.unprotected)) throw new errors_js_1.JWEInvalid("JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint");
1352
+ const joseHeader = {
1353
+ ...parsedProt,
1354
+ ...jwe.header,
1355
+ ...jwe.unprotected
1356
+ };
1357
+ (0, validate_crit_js_1.default)(errors_js_1.JWEInvalid, /* @__PURE__ */ new Map(), options?.crit, parsedProt, joseHeader);
1358
+ if (joseHeader.zip !== void 0) throw new errors_js_1.JOSENotSupported("JWE \"zip\" (Compression Algorithm) Header Parameter is not supported.");
1359
+ const { alg, enc } = joseHeader;
1360
+ if (typeof alg !== "string" || !alg) throw new errors_js_1.JWEInvalid("missing JWE Algorithm (alg) in JWE Header");
1361
+ if (typeof enc !== "string" || !enc) throw new errors_js_1.JWEInvalid("missing JWE Encryption Algorithm (enc) in JWE Header");
1362
+ const keyManagementAlgorithms = options && (0, validate_algorithms_js_1.default)("keyManagementAlgorithms", options.keyManagementAlgorithms);
1363
+ const contentEncryptionAlgorithms = options && (0, validate_algorithms_js_1.default)("contentEncryptionAlgorithms", options.contentEncryptionAlgorithms);
1364
+ if (keyManagementAlgorithms && !keyManagementAlgorithms.has(alg) || !keyManagementAlgorithms && alg.startsWith("PBES2")) throw new errors_js_1.JOSEAlgNotAllowed("\"alg\" (Algorithm) Header Parameter value not allowed");
1365
+ if (contentEncryptionAlgorithms && !contentEncryptionAlgorithms.has(enc)) throw new errors_js_1.JOSEAlgNotAllowed("\"enc\" (Encryption Algorithm) Header Parameter value not allowed");
1366
+ let encryptedKey;
1367
+ if (jwe.encrypted_key !== void 0) try {
1368
+ encryptedKey = (0, base64url_js_1.decode)(jwe.encrypted_key);
1369
+ } catch {
1370
+ throw new errors_js_1.JWEInvalid("Failed to base64url decode the encrypted_key");
1371
+ }
1372
+ let resolvedKey = false;
1373
+ if (typeof key === "function") {
1374
+ key = await key(parsedProt, jwe);
1375
+ resolvedKey = true;
1376
+ }
1377
+ let cek;
1378
+ try {
1379
+ cek = await (0, decrypt_key_management_js_1.default)(alg, key, encryptedKey, joseHeader, options);
1380
+ } catch (err) {
1381
+ if (err instanceof TypeError || err instanceof errors_js_1.JWEInvalid || err instanceof errors_js_1.JOSENotSupported) throw err;
1382
+ cek = (0, cek_js_1.default)(enc);
1383
+ }
1384
+ let iv;
1385
+ let tag;
1386
+ if (jwe.iv !== void 0) try {
1387
+ iv = (0, base64url_js_1.decode)(jwe.iv);
1388
+ } catch {
1389
+ throw new errors_js_1.JWEInvalid("Failed to base64url decode the iv");
1390
+ }
1391
+ if (jwe.tag !== void 0) try {
1392
+ tag = (0, base64url_js_1.decode)(jwe.tag);
1393
+ } catch {
1394
+ throw new errors_js_1.JWEInvalid("Failed to base64url decode the tag");
1395
+ }
1396
+ const protectedHeader = buffer_utils_js_1.encoder.encode(jwe.protected ?? "");
1397
+ let additionalData;
1398
+ if (jwe.aad !== void 0) additionalData = (0, buffer_utils_js_1.concat)(protectedHeader, buffer_utils_js_1.encoder.encode("."), buffer_utils_js_1.encoder.encode(jwe.aad));
1399
+ else additionalData = protectedHeader;
1400
+ let ciphertext;
1401
+ try {
1402
+ ciphertext = (0, base64url_js_1.decode)(jwe.ciphertext);
1403
+ } catch {
1404
+ throw new errors_js_1.JWEInvalid("Failed to base64url decode the ciphertext");
1405
+ }
1406
+ const result = { plaintext: await (0, decrypt_js_1.default)(enc, cek, ciphertext, iv, tag, additionalData) };
1407
+ if (jwe.protected !== void 0) result.protectedHeader = parsedProt;
1408
+ if (jwe.aad !== void 0) try {
1409
+ result.additionalAuthenticatedData = (0, base64url_js_1.decode)(jwe.aad);
1410
+ } catch {
1411
+ throw new errors_js_1.JWEInvalid("Failed to base64url decode the aad");
1412
+ }
1413
+ if (jwe.unprotected !== void 0) result.sharedUnprotectedHeader = jwe.unprotected;
1414
+ if (jwe.header !== void 0) result.unprotectedHeader = jwe.header;
1415
+ if (resolvedKey) return {
1416
+ ...result,
1417
+ key
1418
+ };
1419
+ return result;
1420
+ }
1421
+ }));
1422
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwe/compact/decrypt.js
1423
+ var require_decrypt$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
1424
+ Object.defineProperty(exports, "__esModule", { value: true });
1425
+ exports.compactDecrypt = compactDecrypt;
1426
+ var decrypt_js_1 = require_decrypt$3();
1427
+ var errors_js_1 = require_errors();
1428
+ var buffer_utils_js_1 = require_buffer_utils();
1429
+ async function compactDecrypt(jwe, key, options) {
1430
+ if (jwe instanceof Uint8Array) jwe = buffer_utils_js_1.decoder.decode(jwe);
1431
+ if (typeof jwe !== "string") throw new errors_js_1.JWEInvalid("Compact JWE must be a string or Uint8Array");
1432
+ const { 0: protectedHeader, 1: encryptedKey, 2: iv, 3: ciphertext, 4: tag, length } = jwe.split(".");
1433
+ if (length !== 5) throw new errors_js_1.JWEInvalid("Invalid Compact JWE");
1434
+ const decrypted = await (0, decrypt_js_1.flattenedDecrypt)({
1435
+ ciphertext,
1436
+ iv: iv || void 0,
1437
+ protected: protectedHeader,
1438
+ tag: tag || void 0,
1439
+ encrypted_key: encryptedKey || void 0
1440
+ }, key, options);
1441
+ const result = {
1442
+ plaintext: decrypted.plaintext,
1443
+ protectedHeader: decrypted.protectedHeader
1444
+ };
1445
+ if (typeof key === "function") return {
1446
+ ...result,
1447
+ key: decrypted.key
1448
+ };
1449
+ return result;
1450
+ }
1451
+ }));
1452
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwe/general/decrypt.js
1453
+ var require_decrypt$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
1454
+ Object.defineProperty(exports, "__esModule", { value: true });
1455
+ exports.generalDecrypt = generalDecrypt;
1456
+ var decrypt_js_1 = require_decrypt$3();
1457
+ var errors_js_1 = require_errors();
1458
+ var is_object_js_1 = require_is_object();
1459
+ async function generalDecrypt(jwe, key, options) {
1460
+ if (!(0, is_object_js_1.default)(jwe)) throw new errors_js_1.JWEInvalid("General JWE must be an object");
1461
+ if (!Array.isArray(jwe.recipients) || !jwe.recipients.every(is_object_js_1.default)) throw new errors_js_1.JWEInvalid("JWE Recipients missing or incorrect type");
1462
+ if (!jwe.recipients.length) throw new errors_js_1.JWEInvalid("JWE Recipients has no members");
1463
+ for (const recipient of jwe.recipients) try {
1464
+ return await (0, decrypt_js_1.flattenedDecrypt)({
1465
+ aad: jwe.aad,
1466
+ ciphertext: jwe.ciphertext,
1467
+ encrypted_key: recipient.encrypted_key,
1468
+ header: recipient.header,
1469
+ iv: jwe.iv,
1470
+ protected: jwe.protected,
1471
+ tag: jwe.tag,
1472
+ unprotected: jwe.unprotected
1473
+ }, key, options);
1474
+ } catch {}
1475
+ throw new errors_js_1.JWEDecryptionFailed();
1476
+ }
1477
+ }));
1478
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/private_symbols.js
1479
+ var require_private_symbols = /* @__PURE__ */ __commonJSMin(((exports) => {
1480
+ Object.defineProperty(exports, "__esModule", { value: true });
1481
+ exports.unprotected = void 0;
1482
+ exports.unprotected = Symbol();
1483
+ }));
1484
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/key_to_jwk.js
1485
+ var require_key_to_jwk = /* @__PURE__ */ __commonJSMin(((exports) => {
1486
+ Object.defineProperty(exports, "__esModule", { value: true });
1487
+ var node_crypto_1 = __require("node:crypto");
1488
+ var base64url_js_1 = require_base64url$1();
1489
+ var errors_js_1 = require_errors();
1490
+ var webcrypto_js_1 = require_webcrypto();
1491
+ var is_key_object_js_1 = require_is_key_object();
1492
+ var invalid_key_input_js_1 = require_invalid_key_input();
1493
+ var is_key_like_js_1 = require_is_key_like();
1494
+ var keyToJWK = (key) => {
1495
+ let keyObject;
1496
+ if ((0, webcrypto_js_1.isCryptoKey)(key)) {
1497
+ if (!key.extractable) throw new TypeError("CryptoKey is not extractable");
1498
+ keyObject = node_crypto_1.KeyObject.from(key);
1499
+ } else if ((0, is_key_object_js_1.default)(key)) keyObject = key;
1500
+ else if (key instanceof Uint8Array) return {
1501
+ kty: "oct",
1502
+ k: (0, base64url_js_1.encode)(key)
1503
+ };
1504
+ else throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, "Uint8Array"));
1505
+ if (keyObject.type !== "secret" && ![
1506
+ "rsa",
1507
+ "ec",
1508
+ "ed25519",
1509
+ "x25519",
1510
+ "ed448",
1511
+ "x448"
1512
+ ].includes(keyObject.asymmetricKeyType)) throw new errors_js_1.JOSENotSupported("Unsupported key asymmetricKeyType");
1513
+ return keyObject.export({ format: "jwk" });
1514
+ };
1515
+ exports.default = keyToJWK;
1516
+ }));
1517
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/key/export.js
1518
+ var require_export = /* @__PURE__ */ __commonJSMin(((exports) => {
1519
+ Object.defineProperty(exports, "__esModule", { value: true });
1520
+ exports.exportSPKI = exportSPKI;
1521
+ exports.exportPKCS8 = exportPKCS8;
1522
+ exports.exportJWK = exportJWK;
1523
+ var asn1_js_1 = require_asn1();
1524
+ var asn1_js_2 = require_asn1();
1525
+ var key_to_jwk_js_1 = require_key_to_jwk();
1526
+ async function exportSPKI(key) {
1527
+ return (0, asn1_js_1.toSPKI)(key);
1528
+ }
1529
+ async function exportPKCS8(key) {
1530
+ return (0, asn1_js_2.toPKCS8)(key);
1531
+ }
1532
+ async function exportJWK(key) {
1533
+ return (0, key_to_jwk_js_1.default)(key);
1534
+ }
1535
+ }));
1536
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/encrypt_key_management.js
1537
+ var require_encrypt_key_management = /* @__PURE__ */ __commonJSMin(((exports) => {
1538
+ Object.defineProperty(exports, "__esModule", { value: true });
1539
+ var aeskw_js_1 = require_aeskw();
1540
+ var ECDH = require_ecdhes();
1541
+ var pbes2kw_js_1 = require_pbes2kw();
1542
+ var rsaes_js_1 = require_rsaes();
1543
+ var base64url_js_1 = require_base64url$1();
1544
+ var normalize_key_js_1 = require_normalize_key();
1545
+ var cek_js_1 = require_cek();
1546
+ var errors_js_1 = require_errors();
1547
+ var export_js_1 = require_export();
1548
+ var check_key_type_js_1 = require_check_key_type();
1549
+ var aesgcmkw_js_1 = require_aesgcmkw();
1550
+ async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) {
1551
+ let encryptedKey;
1552
+ let parameters;
1553
+ let cek;
1554
+ (0, check_key_type_js_1.default)(alg, key, "encrypt");
1555
+ key = await normalize_key_js_1.default.normalizePublicKey?.(key, alg) || key;
1556
+ switch (alg) {
1557
+ case "dir":
1558
+ cek = key;
1559
+ break;
1560
+ case "ECDH-ES":
1561
+ case "ECDH-ES+A128KW":
1562
+ case "ECDH-ES+A192KW":
1563
+ case "ECDH-ES+A256KW": {
1564
+ if (!ECDH.ecdhAllowed(key)) throw new errors_js_1.JOSENotSupported("ECDH with the provided key is not allowed or not supported by your javascript runtime");
1565
+ const { apu, apv } = providedParameters;
1566
+ let { epk: ephemeralKey } = providedParameters;
1567
+ ephemeralKey ||= (await ECDH.generateEpk(key)).privateKey;
1568
+ const { x, y, crv, kty } = await (0, export_js_1.exportJWK)(ephemeralKey);
1569
+ const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === "ECDH-ES" ? enc : alg, alg === "ECDH-ES" ? (0, cek_js_1.bitLength)(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
1570
+ parameters = { epk: {
1571
+ x,
1572
+ crv,
1573
+ kty
1574
+ } };
1575
+ if (kty === "EC") parameters.epk.y = y;
1576
+ if (apu) parameters.apu = (0, base64url_js_1.encode)(apu);
1577
+ if (apv) parameters.apv = (0, base64url_js_1.encode)(apv);
1578
+ if (alg === "ECDH-ES") {
1579
+ cek = sharedSecret;
1580
+ break;
1581
+ }
1582
+ cek = providedCek || (0, cek_js_1.default)(enc);
1583
+ const kwAlg = alg.slice(-6);
1584
+ encryptedKey = await (0, aeskw_js_1.wrap)(kwAlg, sharedSecret, cek);
1585
+ break;
1586
+ }
1587
+ case "RSA1_5":
1588
+ case "RSA-OAEP":
1589
+ case "RSA-OAEP-256":
1590
+ case "RSA-OAEP-384":
1591
+ case "RSA-OAEP-512":
1592
+ cek = providedCek || (0, cek_js_1.default)(enc);
1593
+ encryptedKey = await (0, rsaes_js_1.encrypt)(alg, key, cek);
1594
+ break;
1595
+ case "PBES2-HS256+A128KW":
1596
+ case "PBES2-HS384+A192KW":
1597
+ case "PBES2-HS512+A256KW": {
1598
+ cek = providedCek || (0, cek_js_1.default)(enc);
1599
+ const { p2c, p2s } = providedParameters;
1600
+ ({encryptedKey, ...parameters} = await (0, pbes2kw_js_1.encrypt)(alg, key, cek, p2c, p2s));
1601
+ break;
1602
+ }
1603
+ case "A128KW":
1604
+ case "A192KW":
1605
+ case "A256KW":
1606
+ cek = providedCek || (0, cek_js_1.default)(enc);
1607
+ encryptedKey = await (0, aeskw_js_1.wrap)(alg, key, cek);
1608
+ break;
1609
+ case "A128GCMKW":
1610
+ case "A192GCMKW":
1611
+ case "A256GCMKW": {
1612
+ cek = providedCek || (0, cek_js_1.default)(enc);
1613
+ const { iv } = providedParameters;
1614
+ ({encryptedKey, ...parameters} = await (0, aesgcmkw_js_1.wrap)(alg, key, cek, iv));
1615
+ break;
1616
+ }
1617
+ default: throw new errors_js_1.JOSENotSupported("Invalid or unsupported \"alg\" (JWE Algorithm) header value");
1618
+ }
1619
+ return {
1620
+ cek,
1621
+ encryptedKey,
1622
+ parameters
1623
+ };
1624
+ }
1625
+ exports.default = encryptKeyManagement;
1626
+ }));
1627
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwe/flattened/encrypt.js
1628
+ var require_encrypt$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
1629
+ Object.defineProperty(exports, "__esModule", { value: true });
1630
+ exports.FlattenedEncrypt = void 0;
1631
+ var base64url_js_1 = require_base64url$1();
1632
+ var private_symbols_js_1 = require_private_symbols();
1633
+ var encrypt_js_1 = require_encrypt$4();
1634
+ var encrypt_key_management_js_1 = require_encrypt_key_management();
1635
+ var errors_js_1 = require_errors();
1636
+ var is_disjoint_js_1 = require_is_disjoint();
1637
+ var buffer_utils_js_1 = require_buffer_utils();
1638
+ var validate_crit_js_1 = require_validate_crit();
1639
+ var FlattenedEncrypt = class {
1640
+ _plaintext;
1641
+ _protectedHeader;
1642
+ _sharedUnprotectedHeader;
1643
+ _unprotectedHeader;
1644
+ _aad;
1645
+ _cek;
1646
+ _iv;
1647
+ _keyManagementParameters;
1648
+ constructor(plaintext) {
1649
+ if (!(plaintext instanceof Uint8Array)) throw new TypeError("plaintext must be an instance of Uint8Array");
1650
+ this._plaintext = plaintext;
1651
+ }
1652
+ setKeyManagementParameters(parameters) {
1653
+ if (this._keyManagementParameters) throw new TypeError("setKeyManagementParameters can only be called once");
1654
+ this._keyManagementParameters = parameters;
1655
+ return this;
1656
+ }
1657
+ setProtectedHeader(protectedHeader) {
1658
+ if (this._protectedHeader) throw new TypeError("setProtectedHeader can only be called once");
1659
+ this._protectedHeader = protectedHeader;
1660
+ return this;
1661
+ }
1662
+ setSharedUnprotectedHeader(sharedUnprotectedHeader) {
1663
+ if (this._sharedUnprotectedHeader) throw new TypeError("setSharedUnprotectedHeader can only be called once");
1664
+ this._sharedUnprotectedHeader = sharedUnprotectedHeader;
1665
+ return this;
1666
+ }
1667
+ setUnprotectedHeader(unprotectedHeader) {
1668
+ if (this._unprotectedHeader) throw new TypeError("setUnprotectedHeader can only be called once");
1669
+ this._unprotectedHeader = unprotectedHeader;
1670
+ return this;
1671
+ }
1672
+ setAdditionalAuthenticatedData(aad) {
1673
+ this._aad = aad;
1674
+ return this;
1675
+ }
1676
+ setContentEncryptionKey(cek) {
1677
+ if (this._cek) throw new TypeError("setContentEncryptionKey can only be called once");
1678
+ this._cek = cek;
1679
+ return this;
1680
+ }
1681
+ setInitializationVector(iv) {
1682
+ if (this._iv) throw new TypeError("setInitializationVector can only be called once");
1683
+ this._iv = iv;
1684
+ return this;
1685
+ }
1686
+ async encrypt(key, options) {
1687
+ if (!this._protectedHeader && !this._unprotectedHeader && !this._sharedUnprotectedHeader) throw new errors_js_1.JWEInvalid("either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()");
1688
+ if (!(0, is_disjoint_js_1.default)(this._protectedHeader, this._unprotectedHeader, this._sharedUnprotectedHeader)) throw new errors_js_1.JWEInvalid("JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint");
1689
+ const joseHeader = {
1690
+ ...this._protectedHeader,
1691
+ ...this._unprotectedHeader,
1692
+ ...this._sharedUnprotectedHeader
1693
+ };
1694
+ (0, validate_crit_js_1.default)(errors_js_1.JWEInvalid, /* @__PURE__ */ new Map(), options?.crit, this._protectedHeader, joseHeader);
1695
+ if (joseHeader.zip !== void 0) throw new errors_js_1.JOSENotSupported("JWE \"zip\" (Compression Algorithm) Header Parameter is not supported.");
1696
+ const { alg, enc } = joseHeader;
1697
+ if (typeof alg !== "string" || !alg) throw new errors_js_1.JWEInvalid("JWE \"alg\" (Algorithm) Header Parameter missing or invalid");
1698
+ if (typeof enc !== "string" || !enc) throw new errors_js_1.JWEInvalid("JWE \"enc\" (Encryption Algorithm) Header Parameter missing or invalid");
1699
+ let encryptedKey;
1700
+ if (this._cek && (alg === "dir" || alg === "ECDH-ES")) throw new TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${alg}`);
1701
+ let cek;
1702
+ {
1703
+ let parameters;
1704
+ ({cek, encryptedKey, parameters} = await (0, encrypt_key_management_js_1.default)(alg, enc, key, this._cek, this._keyManagementParameters));
1705
+ if (parameters) {
1706
+ if (options && private_symbols_js_1.unprotected in options) {
1707
+ if (!this._unprotectedHeader) this.setUnprotectedHeader(parameters);
1708
+ else this._unprotectedHeader = {
1709
+ ...this._unprotectedHeader,
1710
+ ...parameters
1711
+ };
1712
+ } else if (!this._protectedHeader) this.setProtectedHeader(parameters);
1713
+ else this._protectedHeader = {
1714
+ ...this._protectedHeader,
1715
+ ...parameters
1716
+ };
1717
+ }
1718
+ }
1719
+ let additionalData;
1720
+ let protectedHeader;
1721
+ let aadMember;
1722
+ if (this._protectedHeader) protectedHeader = buffer_utils_js_1.encoder.encode((0, base64url_js_1.encode)(JSON.stringify(this._protectedHeader)));
1723
+ else protectedHeader = buffer_utils_js_1.encoder.encode("");
1724
+ if (this._aad) {
1725
+ aadMember = (0, base64url_js_1.encode)(this._aad);
1726
+ additionalData = (0, buffer_utils_js_1.concat)(protectedHeader, buffer_utils_js_1.encoder.encode("."), buffer_utils_js_1.encoder.encode(aadMember));
1727
+ } else additionalData = protectedHeader;
1728
+ const { ciphertext, tag, iv } = await (0, encrypt_js_1.default)(enc, this._plaintext, cek, this._iv, additionalData);
1729
+ const jwe = { ciphertext: (0, base64url_js_1.encode)(ciphertext) };
1730
+ if (iv) jwe.iv = (0, base64url_js_1.encode)(iv);
1731
+ if (tag) jwe.tag = (0, base64url_js_1.encode)(tag);
1732
+ if (encryptedKey) jwe.encrypted_key = (0, base64url_js_1.encode)(encryptedKey);
1733
+ if (aadMember) jwe.aad = aadMember;
1734
+ if (this._protectedHeader) jwe.protected = buffer_utils_js_1.decoder.decode(protectedHeader);
1735
+ if (this._sharedUnprotectedHeader) jwe.unprotected = this._sharedUnprotectedHeader;
1736
+ if (this._unprotectedHeader) jwe.header = this._unprotectedHeader;
1737
+ return jwe;
1738
+ }
1739
+ };
1740
+ exports.FlattenedEncrypt = FlattenedEncrypt;
1741
+ }));
1742
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwe/general/encrypt.js
1743
+ var require_encrypt$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
1744
+ Object.defineProperty(exports, "__esModule", { value: true });
1745
+ exports.GeneralEncrypt = void 0;
1746
+ var encrypt_js_1 = require_encrypt$3();
1747
+ var private_symbols_js_1 = require_private_symbols();
1748
+ var errors_js_1 = require_errors();
1749
+ var cek_js_1 = require_cek();
1750
+ var is_disjoint_js_1 = require_is_disjoint();
1751
+ var encrypt_key_management_js_1 = require_encrypt_key_management();
1752
+ var base64url_js_1 = require_base64url$1();
1753
+ var validate_crit_js_1 = require_validate_crit();
1754
+ var IndividualRecipient = class {
1755
+ parent;
1756
+ unprotectedHeader;
1757
+ key;
1758
+ options;
1759
+ constructor(enc, key, options) {
1760
+ this.parent = enc;
1761
+ this.key = key;
1762
+ this.options = options;
1763
+ }
1764
+ setUnprotectedHeader(unprotectedHeader) {
1765
+ if (this.unprotectedHeader) throw new TypeError("setUnprotectedHeader can only be called once");
1766
+ this.unprotectedHeader = unprotectedHeader;
1767
+ return this;
1768
+ }
1769
+ addRecipient(...args) {
1770
+ return this.parent.addRecipient(...args);
1771
+ }
1772
+ encrypt(...args) {
1773
+ return this.parent.encrypt(...args);
1774
+ }
1775
+ done() {
1776
+ return this.parent;
1777
+ }
1778
+ };
1779
+ var GeneralEncrypt = class {
1780
+ _plaintext;
1781
+ _recipients = [];
1782
+ _protectedHeader;
1783
+ _unprotectedHeader;
1784
+ _aad;
1785
+ constructor(plaintext) {
1786
+ this._plaintext = plaintext;
1787
+ }
1788
+ addRecipient(key, options) {
1789
+ const recipient = new IndividualRecipient(this, key, { crit: options?.crit });
1790
+ this._recipients.push(recipient);
1791
+ return recipient;
1792
+ }
1793
+ setProtectedHeader(protectedHeader) {
1794
+ if (this._protectedHeader) throw new TypeError("setProtectedHeader can only be called once");
1795
+ this._protectedHeader = protectedHeader;
1796
+ return this;
1797
+ }
1798
+ setSharedUnprotectedHeader(sharedUnprotectedHeader) {
1799
+ if (this._unprotectedHeader) throw new TypeError("setSharedUnprotectedHeader can only be called once");
1800
+ this._unprotectedHeader = sharedUnprotectedHeader;
1801
+ return this;
1802
+ }
1803
+ setAdditionalAuthenticatedData(aad) {
1804
+ this._aad = aad;
1805
+ return this;
1806
+ }
1807
+ async encrypt() {
1808
+ if (!this._recipients.length) throw new errors_js_1.JWEInvalid("at least one recipient must be added");
1809
+ if (this._recipients.length === 1) {
1810
+ const [recipient] = this._recipients;
1811
+ const flattened = await new encrypt_js_1.FlattenedEncrypt(this._plaintext).setAdditionalAuthenticatedData(this._aad).setProtectedHeader(this._protectedHeader).setSharedUnprotectedHeader(this._unprotectedHeader).setUnprotectedHeader(recipient.unprotectedHeader).encrypt(recipient.key, { ...recipient.options });
1812
+ const jwe = {
1813
+ ciphertext: flattened.ciphertext,
1814
+ iv: flattened.iv,
1815
+ recipients: [{}],
1816
+ tag: flattened.tag
1817
+ };
1818
+ if (flattened.aad) jwe.aad = flattened.aad;
1819
+ if (flattened.protected) jwe.protected = flattened.protected;
1820
+ if (flattened.unprotected) jwe.unprotected = flattened.unprotected;
1821
+ if (flattened.encrypted_key) jwe.recipients[0].encrypted_key = flattened.encrypted_key;
1822
+ if (flattened.header) jwe.recipients[0].header = flattened.header;
1823
+ return jwe;
1824
+ }
1825
+ let enc;
1826
+ for (let i = 0; i < this._recipients.length; i++) {
1827
+ const recipient = this._recipients[i];
1828
+ if (!(0, is_disjoint_js_1.default)(this._protectedHeader, this._unprotectedHeader, recipient.unprotectedHeader)) throw new errors_js_1.JWEInvalid("JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint");
1829
+ const joseHeader = {
1830
+ ...this._protectedHeader,
1831
+ ...this._unprotectedHeader,
1832
+ ...recipient.unprotectedHeader
1833
+ };
1834
+ const { alg } = joseHeader;
1835
+ if (typeof alg !== "string" || !alg) throw new errors_js_1.JWEInvalid("JWE \"alg\" (Algorithm) Header Parameter missing or invalid");
1836
+ if (alg === "dir" || alg === "ECDH-ES") throw new errors_js_1.JWEInvalid("\"dir\" and \"ECDH-ES\" alg may only be used with a single recipient");
1837
+ if (typeof joseHeader.enc !== "string" || !joseHeader.enc) throw new errors_js_1.JWEInvalid("JWE \"enc\" (Encryption Algorithm) Header Parameter missing or invalid");
1838
+ if (!enc) enc = joseHeader.enc;
1839
+ else if (enc !== joseHeader.enc) throw new errors_js_1.JWEInvalid("JWE \"enc\" (Encryption Algorithm) Header Parameter must be the same for all recipients");
1840
+ (0, validate_crit_js_1.default)(errors_js_1.JWEInvalid, /* @__PURE__ */ new Map(), recipient.options.crit, this._protectedHeader, joseHeader);
1841
+ if (joseHeader.zip !== void 0) throw new errors_js_1.JOSENotSupported("JWE \"zip\" (Compression Algorithm) Header Parameter is not supported.");
1842
+ }
1843
+ const cek = (0, cek_js_1.default)(enc);
1844
+ const jwe = {
1845
+ ciphertext: "",
1846
+ iv: "",
1847
+ recipients: [],
1848
+ tag: ""
1849
+ };
1850
+ for (let i = 0; i < this._recipients.length; i++) {
1851
+ const recipient = this._recipients[i];
1852
+ const target = {};
1853
+ jwe.recipients.push(target);
1854
+ const p2c = {
1855
+ ...this._protectedHeader,
1856
+ ...this._unprotectedHeader,
1857
+ ...recipient.unprotectedHeader
1858
+ }.alg.startsWith("PBES2") ? 2048 + i : void 0;
1859
+ if (i === 0) {
1860
+ const flattened = await new encrypt_js_1.FlattenedEncrypt(this._plaintext).setAdditionalAuthenticatedData(this._aad).setContentEncryptionKey(cek).setProtectedHeader(this._protectedHeader).setSharedUnprotectedHeader(this._unprotectedHeader).setUnprotectedHeader(recipient.unprotectedHeader).setKeyManagementParameters({ p2c }).encrypt(recipient.key, {
1861
+ ...recipient.options,
1862
+ [private_symbols_js_1.unprotected]: true
1863
+ });
1864
+ jwe.ciphertext = flattened.ciphertext;
1865
+ jwe.iv = flattened.iv;
1866
+ jwe.tag = flattened.tag;
1867
+ if (flattened.aad) jwe.aad = flattened.aad;
1868
+ if (flattened.protected) jwe.protected = flattened.protected;
1869
+ if (flattened.unprotected) jwe.unprotected = flattened.unprotected;
1870
+ target.encrypted_key = flattened.encrypted_key;
1871
+ if (flattened.header) target.header = flattened.header;
1872
+ continue;
1873
+ }
1874
+ const { encryptedKey, parameters } = await (0, encrypt_key_management_js_1.default)(recipient.unprotectedHeader?.alg || this._protectedHeader?.alg || this._unprotectedHeader?.alg, enc, recipient.key, cek, { p2c });
1875
+ target.encrypted_key = (0, base64url_js_1.encode)(encryptedKey);
1876
+ if (recipient.unprotectedHeader || parameters) target.header = {
1877
+ ...recipient.unprotectedHeader,
1878
+ ...parameters
1879
+ };
1880
+ }
1881
+ return jwe;
1882
+ }
1883
+ };
1884
+ exports.GeneralEncrypt = GeneralEncrypt;
1885
+ }));
1886
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/dsa_digest.js
1887
+ var require_dsa_digest = /* @__PURE__ */ __commonJSMin(((exports) => {
1888
+ Object.defineProperty(exports, "__esModule", { value: true });
1889
+ exports.default = dsaDigest;
1890
+ var errors_js_1 = require_errors();
1891
+ function dsaDigest(alg) {
1892
+ switch (alg) {
1893
+ case "PS256":
1894
+ case "RS256":
1895
+ case "ES256":
1896
+ case "ES256K": return "sha256";
1897
+ case "PS384":
1898
+ case "RS384":
1899
+ case "ES384": return "sha384";
1900
+ case "PS512":
1901
+ case "RS512":
1902
+ case "ES512": return "sha512";
1903
+ case "Ed25519":
1904
+ case "EdDSA": return;
1905
+ default: throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
1906
+ }
1907
+ }
1908
+ }));
1909
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/node_key.js
1910
+ var require_node_key = /* @__PURE__ */ __commonJSMin(((exports) => {
1911
+ Object.defineProperty(exports, "__esModule", { value: true });
1912
+ exports.default = keyForCrypto;
1913
+ var node_crypto_1 = __require("node:crypto");
1914
+ var get_named_curve_js_1 = require_get_named_curve();
1915
+ var errors_js_1 = require_errors();
1916
+ var check_key_length_js_1 = require_check_key_length();
1917
+ var ecCurveAlgMap = /* @__PURE__ */ new Map([
1918
+ ["ES256", "P-256"],
1919
+ ["ES256K", "secp256k1"],
1920
+ ["ES384", "P-384"],
1921
+ ["ES512", "P-521"]
1922
+ ]);
1923
+ function keyForCrypto(alg, key) {
1924
+ let asymmetricKeyType;
1925
+ let asymmetricKeyDetails;
1926
+ let isJWK;
1927
+ if (key instanceof node_crypto_1.KeyObject) {
1928
+ asymmetricKeyType = key.asymmetricKeyType;
1929
+ asymmetricKeyDetails = key.asymmetricKeyDetails;
1930
+ } else {
1931
+ isJWK = true;
1932
+ switch (key.kty) {
1933
+ case "RSA":
1934
+ asymmetricKeyType = "rsa";
1935
+ break;
1936
+ case "EC":
1937
+ asymmetricKeyType = "ec";
1938
+ break;
1939
+ case "OKP":
1940
+ if (key.crv === "Ed25519") {
1941
+ asymmetricKeyType = "ed25519";
1942
+ break;
1943
+ }
1944
+ if (key.crv === "Ed448") {
1945
+ asymmetricKeyType = "ed448";
1946
+ break;
1947
+ }
1948
+ throw new TypeError("Invalid key for this operation, its crv must be Ed25519 or Ed448");
1949
+ default: throw new TypeError("Invalid key for this operation, its kty must be RSA, OKP, or EC");
1950
+ }
1951
+ }
1952
+ let options;
1953
+ switch (alg) {
1954
+ case "Ed25519":
1955
+ if (asymmetricKeyType !== "ed25519") throw new TypeError(`Invalid key for this operation, its asymmetricKeyType must be ed25519`);
1956
+ break;
1957
+ case "EdDSA":
1958
+ if (!["ed25519", "ed448"].includes(asymmetricKeyType)) throw new TypeError("Invalid key for this operation, its asymmetricKeyType must be ed25519 or ed448");
1959
+ break;
1960
+ case "RS256":
1961
+ case "RS384":
1962
+ case "RS512":
1963
+ if (asymmetricKeyType !== "rsa") throw new TypeError("Invalid key for this operation, its asymmetricKeyType must be rsa");
1964
+ (0, check_key_length_js_1.default)(key, alg);
1965
+ break;
1966
+ case "PS256":
1967
+ case "PS384":
1968
+ case "PS512":
1969
+ if (asymmetricKeyType === "rsa-pss") {
1970
+ const { hashAlgorithm, mgf1HashAlgorithm, saltLength } = asymmetricKeyDetails;
1971
+ const length = parseInt(alg.slice(-3), 10);
1972
+ if (hashAlgorithm !== void 0 && (hashAlgorithm !== `sha${length}` || mgf1HashAlgorithm !== hashAlgorithm)) throw new TypeError(`Invalid key for this operation, its RSA-PSS parameters do not meet the requirements of "alg" ${alg}`);
1973
+ if (saltLength !== void 0 && saltLength > length >> 3) throw new TypeError(`Invalid key for this operation, its RSA-PSS parameter saltLength does not meet the requirements of "alg" ${alg}`);
1974
+ } else if (asymmetricKeyType !== "rsa") throw new TypeError("Invalid key for this operation, its asymmetricKeyType must be rsa or rsa-pss");
1975
+ (0, check_key_length_js_1.default)(key, alg);
1976
+ options = {
1977
+ padding: node_crypto_1.constants.RSA_PKCS1_PSS_PADDING,
1978
+ saltLength: node_crypto_1.constants.RSA_PSS_SALTLEN_DIGEST
1979
+ };
1980
+ break;
1981
+ case "ES256":
1982
+ case "ES256K":
1983
+ case "ES384":
1984
+ case "ES512": {
1985
+ if (asymmetricKeyType !== "ec") throw new TypeError("Invalid key for this operation, its asymmetricKeyType must be ec");
1986
+ const actual = (0, get_named_curve_js_1.default)(key);
1987
+ const expected = ecCurveAlgMap.get(alg);
1988
+ if (actual !== expected) throw new TypeError(`Invalid key curve for the algorithm, its curve must be ${expected}, got ${actual}`);
1989
+ options = { dsaEncoding: "ieee-p1363" };
1990
+ break;
1991
+ }
1992
+ default: throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
1993
+ }
1994
+ if (isJWK) return {
1995
+ format: "jwk",
1996
+ key,
1997
+ ...options
1998
+ };
1999
+ return options ? {
2000
+ ...options,
2001
+ key
2002
+ } : key;
2003
+ }
2004
+ }));
2005
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/hmac_digest.js
2006
+ var require_hmac_digest = /* @__PURE__ */ __commonJSMin(((exports) => {
2007
+ Object.defineProperty(exports, "__esModule", { value: true });
2008
+ exports.default = hmacDigest;
2009
+ var errors_js_1 = require_errors();
2010
+ function hmacDigest(alg) {
2011
+ switch (alg) {
2012
+ case "HS256": return "sha256";
2013
+ case "HS384": return "sha384";
2014
+ case "HS512": return "sha512";
2015
+ default: throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
2016
+ }
2017
+ }
2018
+ }));
2019
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/get_sign_verify_key.js
2020
+ var require_get_sign_verify_key = /* @__PURE__ */ __commonJSMin(((exports) => {
2021
+ Object.defineProperty(exports, "__esModule", { value: true });
2022
+ exports.default = getSignVerifyKey;
2023
+ var node_crypto_1 = __require("node:crypto");
2024
+ var webcrypto_js_1 = require_webcrypto();
2025
+ var crypto_key_js_1 = require_crypto_key();
2026
+ var invalid_key_input_js_1 = require_invalid_key_input();
2027
+ var is_key_like_js_1 = require_is_key_like();
2028
+ var jwk = require_is_jwk();
2029
+ function getSignVerifyKey(alg, key, usage) {
2030
+ if (key instanceof Uint8Array) {
2031
+ if (!alg.startsWith("HS")) throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
2032
+ return (0, node_crypto_1.createSecretKey)(key);
2033
+ }
2034
+ if (key instanceof node_crypto_1.KeyObject) return key;
2035
+ if ((0, webcrypto_js_1.isCryptoKey)(key)) {
2036
+ (0, crypto_key_js_1.checkSigCryptoKey)(key, alg, usage);
2037
+ return node_crypto_1.KeyObject.from(key);
2038
+ }
2039
+ if (jwk.isJWK(key)) {
2040
+ if (alg.startsWith("HS")) return (0, node_crypto_1.createSecretKey)(Buffer.from(key.k, "base64url"));
2041
+ return key;
2042
+ }
2043
+ throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, "Uint8Array", "JSON Web Key"));
2044
+ }
2045
+ }));
2046
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/sign.js
2047
+ var require_sign$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
2048
+ Object.defineProperty(exports, "__esModule", { value: true });
2049
+ var crypto = __require("node:crypto");
2050
+ var node_util_1 = __require("node:util");
2051
+ var dsa_digest_js_1 = require_dsa_digest();
2052
+ var hmac_digest_js_1 = require_hmac_digest();
2053
+ var node_key_js_1 = require_node_key();
2054
+ var get_sign_verify_key_js_1 = require_get_sign_verify_key();
2055
+ var oneShotSign = (0, node_util_1.promisify)(crypto.sign);
2056
+ var sign = async (alg, key, data) => {
2057
+ const k = (0, get_sign_verify_key_js_1.default)(alg, key, "sign");
2058
+ if (alg.startsWith("HS")) {
2059
+ const hmac = crypto.createHmac((0, hmac_digest_js_1.default)(alg), k);
2060
+ hmac.update(data);
2061
+ return hmac.digest();
2062
+ }
2063
+ return oneShotSign((0, dsa_digest_js_1.default)(alg), data, (0, node_key_js_1.default)(alg, k));
2064
+ };
2065
+ exports.default = sign;
2066
+ }));
2067
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/verify.js
2068
+ var require_verify$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
2069
+ Object.defineProperty(exports, "__esModule", { value: true });
2070
+ var crypto = __require("node:crypto");
2071
+ var node_util_1 = __require("node:util");
2072
+ var dsa_digest_js_1 = require_dsa_digest();
2073
+ var node_key_js_1 = require_node_key();
2074
+ var sign_js_1 = require_sign$4();
2075
+ var get_sign_verify_key_js_1 = require_get_sign_verify_key();
2076
+ var oneShotVerify = (0, node_util_1.promisify)(crypto.verify);
2077
+ var verify = async (alg, key, signature, data) => {
2078
+ const k = (0, get_sign_verify_key_js_1.default)(alg, key, "verify");
2079
+ if (alg.startsWith("HS")) {
2080
+ const expected = await (0, sign_js_1.default)(alg, k, data);
2081
+ const actual = signature;
2082
+ try {
2083
+ return crypto.timingSafeEqual(actual, expected);
2084
+ } catch {
2085
+ return false;
2086
+ }
2087
+ }
2088
+ const algorithm = (0, dsa_digest_js_1.default)(alg);
2089
+ const keyInput = (0, node_key_js_1.default)(alg, k);
2090
+ try {
2091
+ return await oneShotVerify(algorithm, data, keyInput, signature);
2092
+ } catch {
2093
+ return false;
2094
+ }
2095
+ };
2096
+ exports.default = verify;
2097
+ }));
2098
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jws/flattened/verify.js
2099
+ var require_verify$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
2100
+ Object.defineProperty(exports, "__esModule", { value: true });
2101
+ exports.flattenedVerify = flattenedVerify;
2102
+ var base64url_js_1 = require_base64url$1();
2103
+ var verify_js_1 = require_verify$4();
2104
+ var errors_js_1 = require_errors();
2105
+ var buffer_utils_js_1 = require_buffer_utils();
2106
+ var is_disjoint_js_1 = require_is_disjoint();
2107
+ var is_object_js_1 = require_is_object();
2108
+ var check_key_type_js_1 = require_check_key_type();
2109
+ var validate_crit_js_1 = require_validate_crit();
2110
+ var validate_algorithms_js_1 = require_validate_algorithms();
2111
+ var is_jwk_js_1 = require_is_jwk();
2112
+ var import_js_1 = require_import();
2113
+ async function flattenedVerify(jws, key, options) {
2114
+ if (!(0, is_object_js_1.default)(jws)) throw new errors_js_1.JWSInvalid("Flattened JWS must be an object");
2115
+ if (jws.protected === void 0 && jws.header === void 0) throw new errors_js_1.JWSInvalid("Flattened JWS must have either of the \"protected\" or \"header\" members");
2116
+ if (jws.protected !== void 0 && typeof jws.protected !== "string") throw new errors_js_1.JWSInvalid("JWS Protected Header incorrect type");
2117
+ if (jws.payload === void 0) throw new errors_js_1.JWSInvalid("JWS Payload missing");
2118
+ if (typeof jws.signature !== "string") throw new errors_js_1.JWSInvalid("JWS Signature missing or incorrect type");
2119
+ if (jws.header !== void 0 && !(0, is_object_js_1.default)(jws.header)) throw new errors_js_1.JWSInvalid("JWS Unprotected Header incorrect type");
2120
+ let parsedProt = {};
2121
+ if (jws.protected) try {
2122
+ const protectedHeader = (0, base64url_js_1.decode)(jws.protected);
2123
+ parsedProt = JSON.parse(buffer_utils_js_1.decoder.decode(protectedHeader));
2124
+ } catch {
2125
+ throw new errors_js_1.JWSInvalid("JWS Protected Header is invalid");
2126
+ }
2127
+ if (!(0, is_disjoint_js_1.default)(parsedProt, jws.header)) throw new errors_js_1.JWSInvalid("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");
2128
+ const joseHeader = {
2129
+ ...parsedProt,
2130
+ ...jws.header
2131
+ };
2132
+ const extensions = (0, validate_crit_js_1.default)(errors_js_1.JWSInvalid, /* @__PURE__ */ new Map([["b64", true]]), options?.crit, parsedProt, joseHeader);
2133
+ let b64 = true;
2134
+ if (extensions.has("b64")) {
2135
+ b64 = parsedProt.b64;
2136
+ if (typeof b64 !== "boolean") throw new errors_js_1.JWSInvalid("The \"b64\" (base64url-encode payload) Header Parameter must be a boolean");
2137
+ }
2138
+ const { alg } = joseHeader;
2139
+ if (typeof alg !== "string" || !alg) throw new errors_js_1.JWSInvalid("JWS \"alg\" (Algorithm) Header Parameter missing or invalid");
2140
+ const algorithms = options && (0, validate_algorithms_js_1.default)("algorithms", options.algorithms);
2141
+ if (algorithms && !algorithms.has(alg)) throw new errors_js_1.JOSEAlgNotAllowed("\"alg\" (Algorithm) Header Parameter value not allowed");
2142
+ if (b64) {
2143
+ if (typeof jws.payload !== "string") throw new errors_js_1.JWSInvalid("JWS Payload must be a string");
2144
+ } else if (typeof jws.payload !== "string" && !(jws.payload instanceof Uint8Array)) throw new errors_js_1.JWSInvalid("JWS Payload must be a string or an Uint8Array instance");
2145
+ let resolvedKey = false;
2146
+ if (typeof key === "function") {
2147
+ key = await key(parsedProt, jws);
2148
+ resolvedKey = true;
2149
+ (0, check_key_type_js_1.checkKeyTypeWithJwk)(alg, key, "verify");
2150
+ if ((0, is_jwk_js_1.isJWK)(key)) key = await (0, import_js_1.importJWK)(key, alg);
2151
+ } else (0, check_key_type_js_1.checkKeyTypeWithJwk)(alg, key, "verify");
2152
+ const data = (0, buffer_utils_js_1.concat)(buffer_utils_js_1.encoder.encode(jws.protected ?? ""), buffer_utils_js_1.encoder.encode("."), typeof jws.payload === "string" ? buffer_utils_js_1.encoder.encode(jws.payload) : jws.payload);
2153
+ let signature;
2154
+ try {
2155
+ signature = (0, base64url_js_1.decode)(jws.signature);
2156
+ } catch {
2157
+ throw new errors_js_1.JWSInvalid("Failed to base64url decode the signature");
2158
+ }
2159
+ if (!await (0, verify_js_1.default)(alg, key, signature, data)) throw new errors_js_1.JWSSignatureVerificationFailed();
2160
+ let payload;
2161
+ if (b64) try {
2162
+ payload = (0, base64url_js_1.decode)(jws.payload);
2163
+ } catch {
2164
+ throw new errors_js_1.JWSInvalid("Failed to base64url decode the payload");
2165
+ }
2166
+ else if (typeof jws.payload === "string") payload = buffer_utils_js_1.encoder.encode(jws.payload);
2167
+ else payload = jws.payload;
2168
+ const result = { payload };
2169
+ if (jws.protected !== void 0) result.protectedHeader = parsedProt;
2170
+ if (jws.header !== void 0) result.unprotectedHeader = jws.header;
2171
+ if (resolvedKey) return {
2172
+ ...result,
2173
+ key
2174
+ };
2175
+ return result;
2176
+ }
2177
+ }));
2178
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jws/compact/verify.js
2179
+ var require_verify$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
2180
+ Object.defineProperty(exports, "__esModule", { value: true });
2181
+ exports.compactVerify = compactVerify;
2182
+ var verify_js_1 = require_verify$3();
2183
+ var errors_js_1 = require_errors();
2184
+ var buffer_utils_js_1 = require_buffer_utils();
2185
+ async function compactVerify(jws, key, options) {
2186
+ if (jws instanceof Uint8Array) jws = buffer_utils_js_1.decoder.decode(jws);
2187
+ if (typeof jws !== "string") throw new errors_js_1.JWSInvalid("Compact JWS must be a string or Uint8Array");
2188
+ const { 0: protectedHeader, 1: payload, 2: signature, length } = jws.split(".");
2189
+ if (length !== 3) throw new errors_js_1.JWSInvalid("Invalid Compact JWS");
2190
+ const verified = await (0, verify_js_1.flattenedVerify)({
2191
+ payload,
2192
+ protected: protectedHeader,
2193
+ signature
2194
+ }, key, options);
2195
+ const result = {
2196
+ payload: verified.payload,
2197
+ protectedHeader: verified.protectedHeader
2198
+ };
2199
+ if (typeof key === "function") return {
2200
+ ...result,
2201
+ key: verified.key
2202
+ };
2203
+ return result;
2204
+ }
2205
+ }));
2206
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jws/general/verify.js
2207
+ var require_verify$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
2208
+ Object.defineProperty(exports, "__esModule", { value: true });
2209
+ exports.generalVerify = generalVerify;
2210
+ var verify_js_1 = require_verify$3();
2211
+ var errors_js_1 = require_errors();
2212
+ var is_object_js_1 = require_is_object();
2213
+ async function generalVerify(jws, key, options) {
2214
+ if (!(0, is_object_js_1.default)(jws)) throw new errors_js_1.JWSInvalid("General JWS must be an object");
2215
+ if (!Array.isArray(jws.signatures) || !jws.signatures.every(is_object_js_1.default)) throw new errors_js_1.JWSInvalid("JWS Signatures missing or incorrect type");
2216
+ for (const signature of jws.signatures) try {
2217
+ return await (0, verify_js_1.flattenedVerify)({
2218
+ header: signature.header,
2219
+ payload: jws.payload,
2220
+ protected: signature.protected,
2221
+ signature: signature.signature
2222
+ }, key, options);
2223
+ } catch {}
2224
+ throw new errors_js_1.JWSSignatureVerificationFailed();
2225
+ }
2226
+ }));
2227
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/epoch.js
2228
+ var require_epoch = /* @__PURE__ */ __commonJSMin(((exports) => {
2229
+ Object.defineProperty(exports, "__esModule", { value: true });
2230
+ exports.default = (date) => Math.floor(date.getTime() / 1e3);
2231
+ }));
2232
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/secs.js
2233
+ var require_secs = /* @__PURE__ */ __commonJSMin(((exports) => {
2234
+ Object.defineProperty(exports, "__esModule", { value: true });
2235
+ var minute = 60;
2236
+ var hour = 3600;
2237
+ var day = hour * 24;
2238
+ var week = day * 7;
2239
+ var year = day * 365.25;
2240
+ var REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
2241
+ exports.default = (str) => {
2242
+ const matched = REGEX.exec(str);
2243
+ if (!matched || matched[4] && matched[1]) throw new TypeError("Invalid time period format");
2244
+ const value = parseFloat(matched[2]);
2245
+ const unit = matched[3].toLowerCase();
2246
+ let numericDate;
2247
+ switch (unit) {
2248
+ case "sec":
2249
+ case "secs":
2250
+ case "second":
2251
+ case "seconds":
2252
+ case "s":
2253
+ numericDate = Math.round(value);
2254
+ break;
2255
+ case "minute":
2256
+ case "minutes":
2257
+ case "min":
2258
+ case "mins":
2259
+ case "m":
2260
+ numericDate = Math.round(value * minute);
2261
+ break;
2262
+ case "hour":
2263
+ case "hours":
2264
+ case "hr":
2265
+ case "hrs":
2266
+ case "h":
2267
+ numericDate = Math.round(value * hour);
2268
+ break;
2269
+ case "day":
2270
+ case "days":
2271
+ case "d":
2272
+ numericDate = Math.round(value * day);
2273
+ break;
2274
+ case "week":
2275
+ case "weeks":
2276
+ case "w":
2277
+ numericDate = Math.round(value * week);
2278
+ break;
2279
+ default: numericDate = Math.round(value * year);
2280
+ }
2281
+ if (matched[1] === "-" || matched[4] === "ago") return -numericDate;
2282
+ return numericDate;
2283
+ };
2284
+ }));
2285
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/lib/jwt_claims_set.js
2286
+ var require_jwt_claims_set = /* @__PURE__ */ __commonJSMin(((exports) => {
2287
+ Object.defineProperty(exports, "__esModule", { value: true });
2288
+ var errors_js_1 = require_errors();
2289
+ var buffer_utils_js_1 = require_buffer_utils();
2290
+ var epoch_js_1 = require_epoch();
2291
+ var secs_js_1 = require_secs();
2292
+ var is_object_js_1 = require_is_object();
2293
+ var normalizeTyp = (value) => value.toLowerCase().replace(/^application\//, "");
2294
+ var checkAudiencePresence = (audPayload, audOption) => {
2295
+ if (typeof audPayload === "string") return audOption.includes(audPayload);
2296
+ if (Array.isArray(audPayload)) return audOption.some(Set.prototype.has.bind(new Set(audPayload)));
2297
+ return false;
2298
+ };
2299
+ exports.default = (protectedHeader, encodedPayload, options = {}) => {
2300
+ let payload;
2301
+ try {
2302
+ payload = JSON.parse(buffer_utils_js_1.decoder.decode(encodedPayload));
2303
+ } catch {}
2304
+ if (!(0, is_object_js_1.default)(payload)) throw new errors_js_1.JWTInvalid("JWT Claims Set must be a top-level JSON object");
2305
+ const { typ } = options;
2306
+ if (typ && (typeof protectedHeader.typ !== "string" || normalizeTyp(protectedHeader.typ) !== normalizeTyp(typ))) throw new errors_js_1.JWTClaimValidationFailed("unexpected \"typ\" JWT header value", payload, "typ", "check_failed");
2307
+ const { requiredClaims = [], issuer, subject, audience, maxTokenAge } = options;
2308
+ const presenceCheck = [...requiredClaims];
2309
+ if (maxTokenAge !== void 0) presenceCheck.push("iat");
2310
+ if (audience !== void 0) presenceCheck.push("aud");
2311
+ if (subject !== void 0) presenceCheck.push("sub");
2312
+ if (issuer !== void 0) presenceCheck.push("iss");
2313
+ for (const claim of new Set(presenceCheck.reverse())) if (!(claim in payload)) throw new errors_js_1.JWTClaimValidationFailed(`missing required "${claim}" claim`, payload, claim, "missing");
2314
+ if (issuer && !(Array.isArray(issuer) ? issuer : [issuer]).includes(payload.iss)) throw new errors_js_1.JWTClaimValidationFailed("unexpected \"iss\" claim value", payload, "iss", "check_failed");
2315
+ if (subject && payload.sub !== subject) throw new errors_js_1.JWTClaimValidationFailed("unexpected \"sub\" claim value", payload, "sub", "check_failed");
2316
+ if (audience && !checkAudiencePresence(payload.aud, typeof audience === "string" ? [audience] : audience)) throw new errors_js_1.JWTClaimValidationFailed("unexpected \"aud\" claim value", payload, "aud", "check_failed");
2317
+ let tolerance;
2318
+ switch (typeof options.clockTolerance) {
2319
+ case "string":
2320
+ tolerance = (0, secs_js_1.default)(options.clockTolerance);
2321
+ break;
2322
+ case "number":
2323
+ tolerance = options.clockTolerance;
2324
+ break;
2325
+ case "undefined":
2326
+ tolerance = 0;
2327
+ break;
2328
+ default: throw new TypeError("Invalid clockTolerance option type");
2329
+ }
2330
+ const { currentDate } = options;
2331
+ const now = (0, epoch_js_1.default)(currentDate || /* @__PURE__ */ new Date());
2332
+ if ((payload.iat !== void 0 || maxTokenAge) && typeof payload.iat !== "number") throw new errors_js_1.JWTClaimValidationFailed("\"iat\" claim must be a number", payload, "iat", "invalid");
2333
+ if (payload.nbf !== void 0) {
2334
+ if (typeof payload.nbf !== "number") throw new errors_js_1.JWTClaimValidationFailed("\"nbf\" claim must be a number", payload, "nbf", "invalid");
2335
+ if (payload.nbf > now + tolerance) throw new errors_js_1.JWTClaimValidationFailed("\"nbf\" claim timestamp check failed", payload, "nbf", "check_failed");
2336
+ }
2337
+ if (payload.exp !== void 0) {
2338
+ if (typeof payload.exp !== "number") throw new errors_js_1.JWTClaimValidationFailed("\"exp\" claim must be a number", payload, "exp", "invalid");
2339
+ if (payload.exp <= now - tolerance) throw new errors_js_1.JWTExpired("\"exp\" claim timestamp check failed", payload, "exp", "check_failed");
2340
+ }
2341
+ if (maxTokenAge) {
2342
+ const age = now - payload.iat;
2343
+ const max = typeof maxTokenAge === "number" ? maxTokenAge : (0, secs_js_1.default)(maxTokenAge);
2344
+ if (age - tolerance > max) throw new errors_js_1.JWTExpired("\"iat\" claim timestamp check failed (too far in the past)", payload, "iat", "check_failed");
2345
+ if (age < 0 - tolerance) throw new errors_js_1.JWTClaimValidationFailed("\"iat\" claim timestamp check failed (it should be in the past)", payload, "iat", "check_failed");
2346
+ }
2347
+ return payload;
2348
+ };
2349
+ }));
2350
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwt/verify.js
2351
+ var require_verify = /* @__PURE__ */ __commonJSMin(((exports) => {
2352
+ Object.defineProperty(exports, "__esModule", { value: true });
2353
+ exports.jwtVerify = jwtVerify;
2354
+ var verify_js_1 = require_verify$2();
2355
+ var jwt_claims_set_js_1 = require_jwt_claims_set();
2356
+ var errors_js_1 = require_errors();
2357
+ async function jwtVerify(jwt, key, options) {
2358
+ const verified = await (0, verify_js_1.compactVerify)(jwt, key, options);
2359
+ if (verified.protectedHeader.crit?.includes("b64") && verified.protectedHeader.b64 === false) throw new errors_js_1.JWTInvalid("JWTs MUST NOT use unencoded payload");
2360
+ const result = {
2361
+ payload: (0, jwt_claims_set_js_1.default)(verified.protectedHeader, verified.payload, options),
2362
+ protectedHeader: verified.protectedHeader
2363
+ };
2364
+ if (typeof key === "function") return {
2365
+ ...result,
2366
+ key: verified.key
2367
+ };
2368
+ return result;
2369
+ }
2370
+ }));
2371
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwt/decrypt.js
2372
+ var require_decrypt = /* @__PURE__ */ __commonJSMin(((exports) => {
2373
+ Object.defineProperty(exports, "__esModule", { value: true });
2374
+ exports.jwtDecrypt = jwtDecrypt;
2375
+ var decrypt_js_1 = require_decrypt$2();
2376
+ var jwt_claims_set_js_1 = require_jwt_claims_set();
2377
+ var errors_js_1 = require_errors();
2378
+ async function jwtDecrypt(jwt, key, options) {
2379
+ const decrypted = await (0, decrypt_js_1.compactDecrypt)(jwt, key, options);
2380
+ const payload = (0, jwt_claims_set_js_1.default)(decrypted.protectedHeader, decrypted.plaintext, options);
2381
+ const { protectedHeader } = decrypted;
2382
+ if (protectedHeader.iss !== void 0 && protectedHeader.iss !== payload.iss) throw new errors_js_1.JWTClaimValidationFailed("replicated \"iss\" claim header parameter mismatch", payload, "iss", "mismatch");
2383
+ if (protectedHeader.sub !== void 0 && protectedHeader.sub !== payload.sub) throw new errors_js_1.JWTClaimValidationFailed("replicated \"sub\" claim header parameter mismatch", payload, "sub", "mismatch");
2384
+ if (protectedHeader.aud !== void 0 && JSON.stringify(protectedHeader.aud) !== JSON.stringify(payload.aud)) throw new errors_js_1.JWTClaimValidationFailed("replicated \"aud\" claim header parameter mismatch", payload, "aud", "mismatch");
2385
+ const result = {
2386
+ payload,
2387
+ protectedHeader
2388
+ };
2389
+ if (typeof key === "function") return {
2390
+ ...result,
2391
+ key: decrypted.key
2392
+ };
2393
+ return result;
2394
+ }
2395
+ }));
2396
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwe/compact/encrypt.js
2397
+ var require_encrypt$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
2398
+ Object.defineProperty(exports, "__esModule", { value: true });
2399
+ exports.CompactEncrypt = void 0;
2400
+ var encrypt_js_1 = require_encrypt$3();
2401
+ var CompactEncrypt = class {
2402
+ _flattened;
2403
+ constructor(plaintext) {
2404
+ this._flattened = new encrypt_js_1.FlattenedEncrypt(plaintext);
2405
+ }
2406
+ setContentEncryptionKey(cek) {
2407
+ this._flattened.setContentEncryptionKey(cek);
2408
+ return this;
2409
+ }
2410
+ setInitializationVector(iv) {
2411
+ this._flattened.setInitializationVector(iv);
2412
+ return this;
2413
+ }
2414
+ setProtectedHeader(protectedHeader) {
2415
+ this._flattened.setProtectedHeader(protectedHeader);
2416
+ return this;
2417
+ }
2418
+ setKeyManagementParameters(parameters) {
2419
+ this._flattened.setKeyManagementParameters(parameters);
2420
+ return this;
2421
+ }
2422
+ async encrypt(key, options) {
2423
+ const jwe = await this._flattened.encrypt(key, options);
2424
+ return [
2425
+ jwe.protected,
2426
+ jwe.encrypted_key,
2427
+ jwe.iv,
2428
+ jwe.ciphertext,
2429
+ jwe.tag
2430
+ ].join(".");
2431
+ }
2432
+ };
2433
+ exports.CompactEncrypt = CompactEncrypt;
2434
+ }));
2435
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jws/flattened/sign.js
2436
+ var require_sign$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
2437
+ Object.defineProperty(exports, "__esModule", { value: true });
2438
+ exports.FlattenedSign = void 0;
2439
+ var base64url_js_1 = require_base64url$1();
2440
+ var sign_js_1 = require_sign$4();
2441
+ var is_disjoint_js_1 = require_is_disjoint();
2442
+ var errors_js_1 = require_errors();
2443
+ var buffer_utils_js_1 = require_buffer_utils();
2444
+ var check_key_type_js_1 = require_check_key_type();
2445
+ var validate_crit_js_1 = require_validate_crit();
2446
+ var FlattenedSign = class {
2447
+ _payload;
2448
+ _protectedHeader;
2449
+ _unprotectedHeader;
2450
+ constructor(payload) {
2451
+ if (!(payload instanceof Uint8Array)) throw new TypeError("payload must be an instance of Uint8Array");
2452
+ this._payload = payload;
2453
+ }
2454
+ setProtectedHeader(protectedHeader) {
2455
+ if (this._protectedHeader) throw new TypeError("setProtectedHeader can only be called once");
2456
+ this._protectedHeader = protectedHeader;
2457
+ return this;
2458
+ }
2459
+ setUnprotectedHeader(unprotectedHeader) {
2460
+ if (this._unprotectedHeader) throw new TypeError("setUnprotectedHeader can only be called once");
2461
+ this._unprotectedHeader = unprotectedHeader;
2462
+ return this;
2463
+ }
2464
+ async sign(key, options) {
2465
+ if (!this._protectedHeader && !this._unprotectedHeader) throw new errors_js_1.JWSInvalid("either setProtectedHeader or setUnprotectedHeader must be called before #sign()");
2466
+ if (!(0, is_disjoint_js_1.default)(this._protectedHeader, this._unprotectedHeader)) throw new errors_js_1.JWSInvalid("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");
2467
+ const joseHeader = {
2468
+ ...this._protectedHeader,
2469
+ ...this._unprotectedHeader
2470
+ };
2471
+ const extensions = (0, validate_crit_js_1.default)(errors_js_1.JWSInvalid, /* @__PURE__ */ new Map([["b64", true]]), options?.crit, this._protectedHeader, joseHeader);
2472
+ let b64 = true;
2473
+ if (extensions.has("b64")) {
2474
+ b64 = this._protectedHeader.b64;
2475
+ if (typeof b64 !== "boolean") throw new errors_js_1.JWSInvalid("The \"b64\" (base64url-encode payload) Header Parameter must be a boolean");
2476
+ }
2477
+ const { alg } = joseHeader;
2478
+ if (typeof alg !== "string" || !alg) throw new errors_js_1.JWSInvalid("JWS \"alg\" (Algorithm) Header Parameter missing or invalid");
2479
+ (0, check_key_type_js_1.checkKeyTypeWithJwk)(alg, key, "sign");
2480
+ let payload = this._payload;
2481
+ if (b64) payload = buffer_utils_js_1.encoder.encode((0, base64url_js_1.encode)(payload));
2482
+ let protectedHeader;
2483
+ if (this._protectedHeader) protectedHeader = buffer_utils_js_1.encoder.encode((0, base64url_js_1.encode)(JSON.stringify(this._protectedHeader)));
2484
+ else protectedHeader = buffer_utils_js_1.encoder.encode("");
2485
+ const data = (0, buffer_utils_js_1.concat)(protectedHeader, buffer_utils_js_1.encoder.encode("."), payload);
2486
+ const signature = await (0, sign_js_1.default)(alg, key, data);
2487
+ const jws = {
2488
+ signature: (0, base64url_js_1.encode)(signature),
2489
+ payload: ""
2490
+ };
2491
+ if (b64) jws.payload = buffer_utils_js_1.decoder.decode(payload);
2492
+ if (this._unprotectedHeader) jws.header = this._unprotectedHeader;
2493
+ if (this._protectedHeader) jws.protected = buffer_utils_js_1.decoder.decode(protectedHeader);
2494
+ return jws;
2495
+ }
2496
+ };
2497
+ exports.FlattenedSign = FlattenedSign;
2498
+ }));
2499
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jws/compact/sign.js
2500
+ var require_sign$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
2501
+ Object.defineProperty(exports, "__esModule", { value: true });
2502
+ exports.CompactSign = void 0;
2503
+ var sign_js_1 = require_sign$3();
2504
+ var CompactSign = class {
2505
+ _flattened;
2506
+ constructor(payload) {
2507
+ this._flattened = new sign_js_1.FlattenedSign(payload);
2508
+ }
2509
+ setProtectedHeader(protectedHeader) {
2510
+ this._flattened.setProtectedHeader(protectedHeader);
2511
+ return this;
2512
+ }
2513
+ async sign(key, options) {
2514
+ const jws = await this._flattened.sign(key, options);
2515
+ if (jws.payload === void 0) throw new TypeError("use the flattened module for creating JWS with b64: false");
2516
+ return `${jws.protected}.${jws.payload}.${jws.signature}`;
2517
+ }
2518
+ };
2519
+ exports.CompactSign = CompactSign;
2520
+ }));
2521
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jws/general/sign.js
2522
+ var require_sign$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
2523
+ Object.defineProperty(exports, "__esModule", { value: true });
2524
+ exports.GeneralSign = void 0;
2525
+ var sign_js_1 = require_sign$3();
2526
+ var errors_js_1 = require_errors();
2527
+ var IndividualSignature = class {
2528
+ parent;
2529
+ protectedHeader;
2530
+ unprotectedHeader;
2531
+ options;
2532
+ key;
2533
+ constructor(sig, key, options) {
2534
+ this.parent = sig;
2535
+ this.key = key;
2536
+ this.options = options;
2537
+ }
2538
+ setProtectedHeader(protectedHeader) {
2539
+ if (this.protectedHeader) throw new TypeError("setProtectedHeader can only be called once");
2540
+ this.protectedHeader = protectedHeader;
2541
+ return this;
2542
+ }
2543
+ setUnprotectedHeader(unprotectedHeader) {
2544
+ if (this.unprotectedHeader) throw new TypeError("setUnprotectedHeader can only be called once");
2545
+ this.unprotectedHeader = unprotectedHeader;
2546
+ return this;
2547
+ }
2548
+ addSignature(...args) {
2549
+ return this.parent.addSignature(...args);
2550
+ }
2551
+ sign(...args) {
2552
+ return this.parent.sign(...args);
2553
+ }
2554
+ done() {
2555
+ return this.parent;
2556
+ }
2557
+ };
2558
+ var GeneralSign = class {
2559
+ _payload;
2560
+ _signatures = [];
2561
+ constructor(payload) {
2562
+ this._payload = payload;
2563
+ }
2564
+ addSignature(key, options) {
2565
+ const signature = new IndividualSignature(this, key, options);
2566
+ this._signatures.push(signature);
2567
+ return signature;
2568
+ }
2569
+ async sign() {
2570
+ if (!this._signatures.length) throw new errors_js_1.JWSInvalid("at least one signature must be added");
2571
+ const jws = {
2572
+ signatures: [],
2573
+ payload: ""
2574
+ };
2575
+ for (let i = 0; i < this._signatures.length; i++) {
2576
+ const signature = this._signatures[i];
2577
+ const flattened = new sign_js_1.FlattenedSign(this._payload);
2578
+ flattened.setProtectedHeader(signature.protectedHeader);
2579
+ flattened.setUnprotectedHeader(signature.unprotectedHeader);
2580
+ const { payload, ...rest } = await flattened.sign(signature.key, signature.options);
2581
+ if (i === 0) jws.payload = payload;
2582
+ else if (jws.payload !== payload) throw new errors_js_1.JWSInvalid("inconsistent use of JWS Unencoded Payload (RFC7797)");
2583
+ jws.signatures.push(rest);
2584
+ }
2585
+ return jws;
2586
+ }
2587
+ };
2588
+ exports.GeneralSign = GeneralSign;
2589
+ }));
2590
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwt/produce.js
2591
+ var require_produce = /* @__PURE__ */ __commonJSMin(((exports) => {
2592
+ Object.defineProperty(exports, "__esModule", { value: true });
2593
+ exports.ProduceJWT = void 0;
2594
+ var epoch_js_1 = require_epoch();
2595
+ var is_object_js_1 = require_is_object();
2596
+ var secs_js_1 = require_secs();
2597
+ function validateInput(label, input) {
2598
+ if (!Number.isFinite(input)) throw new TypeError(`Invalid ${label} input`);
2599
+ return input;
2600
+ }
2601
+ var ProduceJWT = class {
2602
+ _payload;
2603
+ constructor(payload = {}) {
2604
+ if (!(0, is_object_js_1.default)(payload)) throw new TypeError("JWT Claims Set MUST be an object");
2605
+ this._payload = payload;
2606
+ }
2607
+ setIssuer(issuer) {
2608
+ this._payload = {
2609
+ ...this._payload,
2610
+ iss: issuer
2611
+ };
2612
+ return this;
2613
+ }
2614
+ setSubject(subject) {
2615
+ this._payload = {
2616
+ ...this._payload,
2617
+ sub: subject
2618
+ };
2619
+ return this;
2620
+ }
2621
+ setAudience(audience) {
2622
+ this._payload = {
2623
+ ...this._payload,
2624
+ aud: audience
2625
+ };
2626
+ return this;
2627
+ }
2628
+ setJti(jwtId) {
2629
+ this._payload = {
2630
+ ...this._payload,
2631
+ jti: jwtId
2632
+ };
2633
+ return this;
2634
+ }
2635
+ setNotBefore(input) {
2636
+ if (typeof input === "number") this._payload = {
2637
+ ...this._payload,
2638
+ nbf: validateInput("setNotBefore", input)
2639
+ };
2640
+ else if (input instanceof Date) this._payload = {
2641
+ ...this._payload,
2642
+ nbf: validateInput("setNotBefore", (0, epoch_js_1.default)(input))
2643
+ };
2644
+ else this._payload = {
2645
+ ...this._payload,
2646
+ nbf: (0, epoch_js_1.default)(/* @__PURE__ */ new Date()) + (0, secs_js_1.default)(input)
2647
+ };
2648
+ return this;
2649
+ }
2650
+ setExpirationTime(input) {
2651
+ if (typeof input === "number") this._payload = {
2652
+ ...this._payload,
2653
+ exp: validateInput("setExpirationTime", input)
2654
+ };
2655
+ else if (input instanceof Date) this._payload = {
2656
+ ...this._payload,
2657
+ exp: validateInput("setExpirationTime", (0, epoch_js_1.default)(input))
2658
+ };
2659
+ else this._payload = {
2660
+ ...this._payload,
2661
+ exp: (0, epoch_js_1.default)(/* @__PURE__ */ new Date()) + (0, secs_js_1.default)(input)
2662
+ };
2663
+ return this;
2664
+ }
2665
+ setIssuedAt(input) {
2666
+ if (typeof input === "undefined") this._payload = {
2667
+ ...this._payload,
2668
+ iat: (0, epoch_js_1.default)(/* @__PURE__ */ new Date())
2669
+ };
2670
+ else if (input instanceof Date) this._payload = {
2671
+ ...this._payload,
2672
+ iat: validateInput("setIssuedAt", (0, epoch_js_1.default)(input))
2673
+ };
2674
+ else if (typeof input === "string") this._payload = {
2675
+ ...this._payload,
2676
+ iat: validateInput("setIssuedAt", (0, epoch_js_1.default)(/* @__PURE__ */ new Date()) + (0, secs_js_1.default)(input))
2677
+ };
2678
+ else this._payload = {
2679
+ ...this._payload,
2680
+ iat: validateInput("setIssuedAt", input)
2681
+ };
2682
+ return this;
2683
+ }
2684
+ };
2685
+ exports.ProduceJWT = ProduceJWT;
2686
+ }));
2687
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwt/sign.js
2688
+ var require_sign = /* @__PURE__ */ __commonJSMin(((exports) => {
2689
+ Object.defineProperty(exports, "__esModule", { value: true });
2690
+ exports.SignJWT = void 0;
2691
+ var sign_js_1 = require_sign$2();
2692
+ var errors_js_1 = require_errors();
2693
+ var buffer_utils_js_1 = require_buffer_utils();
2694
+ var produce_js_1 = require_produce();
2695
+ var SignJWT = class extends produce_js_1.ProduceJWT {
2696
+ _protectedHeader;
2697
+ setProtectedHeader(protectedHeader) {
2698
+ this._protectedHeader = protectedHeader;
2699
+ return this;
2700
+ }
2701
+ async sign(key, options) {
2702
+ const sig = new sign_js_1.CompactSign(buffer_utils_js_1.encoder.encode(JSON.stringify(this._payload)));
2703
+ sig.setProtectedHeader(this._protectedHeader);
2704
+ if (Array.isArray(this._protectedHeader?.crit) && this._protectedHeader.crit.includes("b64") && this._protectedHeader.b64 === false) throw new errors_js_1.JWTInvalid("JWTs MUST NOT use unencoded payload");
2705
+ return sig.sign(key, options);
2706
+ }
2707
+ };
2708
+ exports.SignJWT = SignJWT;
2709
+ }));
2710
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwt/encrypt.js
2711
+ var require_encrypt = /* @__PURE__ */ __commonJSMin(((exports) => {
2712
+ Object.defineProperty(exports, "__esModule", { value: true });
2713
+ exports.EncryptJWT = void 0;
2714
+ var encrypt_js_1 = require_encrypt$1();
2715
+ var buffer_utils_js_1 = require_buffer_utils();
2716
+ var produce_js_1 = require_produce();
2717
+ var EncryptJWT = class extends produce_js_1.ProduceJWT {
2718
+ _cek;
2719
+ _iv;
2720
+ _keyManagementParameters;
2721
+ _protectedHeader;
2722
+ _replicateIssuerAsHeader;
2723
+ _replicateSubjectAsHeader;
2724
+ _replicateAudienceAsHeader;
2725
+ setProtectedHeader(protectedHeader) {
2726
+ if (this._protectedHeader) throw new TypeError("setProtectedHeader can only be called once");
2727
+ this._protectedHeader = protectedHeader;
2728
+ return this;
2729
+ }
2730
+ setKeyManagementParameters(parameters) {
2731
+ if (this._keyManagementParameters) throw new TypeError("setKeyManagementParameters can only be called once");
2732
+ this._keyManagementParameters = parameters;
2733
+ return this;
2734
+ }
2735
+ setContentEncryptionKey(cek) {
2736
+ if (this._cek) throw new TypeError("setContentEncryptionKey can only be called once");
2737
+ this._cek = cek;
2738
+ return this;
2739
+ }
2740
+ setInitializationVector(iv) {
2741
+ if (this._iv) throw new TypeError("setInitializationVector can only be called once");
2742
+ this._iv = iv;
2743
+ return this;
2744
+ }
2745
+ replicateIssuerAsHeader() {
2746
+ this._replicateIssuerAsHeader = true;
2747
+ return this;
2748
+ }
2749
+ replicateSubjectAsHeader() {
2750
+ this._replicateSubjectAsHeader = true;
2751
+ return this;
2752
+ }
2753
+ replicateAudienceAsHeader() {
2754
+ this._replicateAudienceAsHeader = true;
2755
+ return this;
2756
+ }
2757
+ async encrypt(key, options) {
2758
+ const enc = new encrypt_js_1.CompactEncrypt(buffer_utils_js_1.encoder.encode(JSON.stringify(this._payload)));
2759
+ if (this._replicateIssuerAsHeader) this._protectedHeader = {
2760
+ ...this._protectedHeader,
2761
+ iss: this._payload.iss
2762
+ };
2763
+ if (this._replicateSubjectAsHeader) this._protectedHeader = {
2764
+ ...this._protectedHeader,
2765
+ sub: this._payload.sub
2766
+ };
2767
+ if (this._replicateAudienceAsHeader) this._protectedHeader = {
2768
+ ...this._protectedHeader,
2769
+ aud: this._payload.aud
2770
+ };
2771
+ enc.setProtectedHeader(this._protectedHeader);
2772
+ if (this._iv) enc.setInitializationVector(this._iv);
2773
+ if (this._cek) enc.setContentEncryptionKey(this._cek);
2774
+ if (this._keyManagementParameters) enc.setKeyManagementParameters(this._keyManagementParameters);
2775
+ return enc.encrypt(key, options);
2776
+ }
2777
+ };
2778
+ exports.EncryptJWT = EncryptJWT;
2779
+ }));
2780
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwk/thumbprint.js
2781
+ var require_thumbprint = /* @__PURE__ */ __commonJSMin(((exports) => {
2782
+ Object.defineProperty(exports, "__esModule", { value: true });
2783
+ exports.calculateJwkThumbprint = calculateJwkThumbprint;
2784
+ exports.calculateJwkThumbprintUri = calculateJwkThumbprintUri;
2785
+ var digest_js_1 = require_digest();
2786
+ var base64url_js_1 = require_base64url$1();
2787
+ var errors_js_1 = require_errors();
2788
+ var buffer_utils_js_1 = require_buffer_utils();
2789
+ var is_object_js_1 = require_is_object();
2790
+ var check = (value, description) => {
2791
+ if (typeof value !== "string" || !value) throw new errors_js_1.JWKInvalid(`${description} missing or invalid`);
2792
+ };
2793
+ async function calculateJwkThumbprint(jwk, digestAlgorithm) {
2794
+ if (!(0, is_object_js_1.default)(jwk)) throw new TypeError("JWK must be an object");
2795
+ digestAlgorithm ??= "sha256";
2796
+ if (digestAlgorithm !== "sha256" && digestAlgorithm !== "sha384" && digestAlgorithm !== "sha512") throw new TypeError("digestAlgorithm must one of \"sha256\", \"sha384\", or \"sha512\"");
2797
+ let components;
2798
+ switch (jwk.kty) {
2799
+ case "EC":
2800
+ check(jwk.crv, "\"crv\" (Curve) Parameter");
2801
+ check(jwk.x, "\"x\" (X Coordinate) Parameter");
2802
+ check(jwk.y, "\"y\" (Y Coordinate) Parameter");
2803
+ components = {
2804
+ crv: jwk.crv,
2805
+ kty: jwk.kty,
2806
+ x: jwk.x,
2807
+ y: jwk.y
2808
+ };
2809
+ break;
2810
+ case "OKP":
2811
+ check(jwk.crv, "\"crv\" (Subtype of Key Pair) Parameter");
2812
+ check(jwk.x, "\"x\" (Public Key) Parameter");
2813
+ components = {
2814
+ crv: jwk.crv,
2815
+ kty: jwk.kty,
2816
+ x: jwk.x
2817
+ };
2818
+ break;
2819
+ case "RSA":
2820
+ check(jwk.e, "\"e\" (Exponent) Parameter");
2821
+ check(jwk.n, "\"n\" (Modulus) Parameter");
2822
+ components = {
2823
+ e: jwk.e,
2824
+ kty: jwk.kty,
2825
+ n: jwk.n
2826
+ };
2827
+ break;
2828
+ case "oct":
2829
+ check(jwk.k, "\"k\" (Key Value) Parameter");
2830
+ components = {
2831
+ k: jwk.k,
2832
+ kty: jwk.kty
2833
+ };
2834
+ break;
2835
+ default: throw new errors_js_1.JOSENotSupported("\"kty\" (Key Type) Parameter missing or unsupported");
2836
+ }
2837
+ const data = buffer_utils_js_1.encoder.encode(JSON.stringify(components));
2838
+ return (0, base64url_js_1.encode)(await (0, digest_js_1.default)(digestAlgorithm, data));
2839
+ }
2840
+ async function calculateJwkThumbprintUri(jwk, digestAlgorithm) {
2841
+ digestAlgorithm ??= "sha256";
2842
+ const thumbprint = await calculateJwkThumbprint(jwk, digestAlgorithm);
2843
+ return `urn:ietf:params:oauth:jwk-thumbprint:sha-${digestAlgorithm.slice(-3)}:${thumbprint}`;
2844
+ }
2845
+ }));
2846
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwk/embedded.js
2847
+ var require_embedded = /* @__PURE__ */ __commonJSMin(((exports) => {
2848
+ Object.defineProperty(exports, "__esModule", { value: true });
2849
+ exports.EmbeddedJWK = EmbeddedJWK;
2850
+ var import_js_1 = require_import();
2851
+ var is_object_js_1 = require_is_object();
2852
+ var errors_js_1 = require_errors();
2853
+ async function EmbeddedJWK(protectedHeader, token) {
2854
+ const joseHeader = {
2855
+ ...protectedHeader,
2856
+ ...token?.header
2857
+ };
2858
+ if (!(0, is_object_js_1.default)(joseHeader.jwk)) throw new errors_js_1.JWSInvalid("\"jwk\" (JSON Web Key) Header Parameter must be a JSON object");
2859
+ const key = await (0, import_js_1.importJWK)({
2860
+ ...joseHeader.jwk,
2861
+ ext: true
2862
+ }, joseHeader.alg);
2863
+ if (key instanceof Uint8Array || key.type !== "public") throw new errors_js_1.JWSInvalid("\"jwk\" (JSON Web Key) Header Parameter must be a public key");
2864
+ return key;
2865
+ }
2866
+ }));
2867
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwks/local.js
2868
+ var require_local = /* @__PURE__ */ __commonJSMin(((exports) => {
2869
+ Object.defineProperty(exports, "__esModule", { value: true });
2870
+ exports.createLocalJWKSet = createLocalJWKSet;
2871
+ var import_js_1 = require_import();
2872
+ var errors_js_1 = require_errors();
2873
+ var is_object_js_1 = require_is_object();
2874
+ function getKtyFromAlg(alg) {
2875
+ switch (typeof alg === "string" && alg.slice(0, 2)) {
2876
+ case "RS":
2877
+ case "PS": return "RSA";
2878
+ case "ES": return "EC";
2879
+ case "Ed": return "OKP";
2880
+ default: throw new errors_js_1.JOSENotSupported("Unsupported \"alg\" value for a JSON Web Key Set");
2881
+ }
2882
+ }
2883
+ function isJWKSLike(jwks) {
2884
+ return jwks && typeof jwks === "object" && Array.isArray(jwks.keys) && jwks.keys.every(isJWKLike);
2885
+ }
2886
+ function isJWKLike(key) {
2887
+ return (0, is_object_js_1.default)(key);
2888
+ }
2889
+ function clone(obj) {
2890
+ if (typeof structuredClone === "function") return structuredClone(obj);
2891
+ return JSON.parse(JSON.stringify(obj));
2892
+ }
2893
+ var LocalJWKSet = class {
2894
+ _jwks;
2895
+ _cached = /* @__PURE__ */ new WeakMap();
2896
+ constructor(jwks) {
2897
+ if (!isJWKSLike(jwks)) throw new errors_js_1.JWKSInvalid("JSON Web Key Set malformed");
2898
+ this._jwks = clone(jwks);
2899
+ }
2900
+ async getKey(protectedHeader, token) {
2901
+ const { alg, kid } = {
2902
+ ...protectedHeader,
2903
+ ...token?.header
2904
+ };
2905
+ const kty = getKtyFromAlg(alg);
2906
+ const candidates = this._jwks.keys.filter((jwk) => {
2907
+ let candidate = kty === jwk.kty;
2908
+ if (candidate && typeof kid === "string") candidate = kid === jwk.kid;
2909
+ if (candidate && typeof jwk.alg === "string") candidate = alg === jwk.alg;
2910
+ if (candidate && typeof jwk.use === "string") candidate = jwk.use === "sig";
2911
+ if (candidate && Array.isArray(jwk.key_ops)) candidate = jwk.key_ops.includes("verify");
2912
+ if (candidate) switch (alg) {
2913
+ case "ES256":
2914
+ candidate = jwk.crv === "P-256";
2915
+ break;
2916
+ case "ES256K":
2917
+ candidate = jwk.crv === "secp256k1";
2918
+ break;
2919
+ case "ES384":
2920
+ candidate = jwk.crv === "P-384";
2921
+ break;
2922
+ case "ES512":
2923
+ candidate = jwk.crv === "P-521";
2924
+ break;
2925
+ case "Ed25519":
2926
+ candidate = jwk.crv === "Ed25519";
2927
+ break;
2928
+ case "EdDSA": candidate = jwk.crv === "Ed25519" || jwk.crv === "Ed448";
2929
+ }
2930
+ return candidate;
2931
+ });
2932
+ const { 0: jwk, length } = candidates;
2933
+ if (length === 0) throw new errors_js_1.JWKSNoMatchingKey();
2934
+ if (length !== 1) {
2935
+ const error = new errors_js_1.JWKSMultipleMatchingKeys();
2936
+ const { _cached } = this;
2937
+ error[Symbol.asyncIterator] = async function* () {
2938
+ for (const jwk of candidates) try {
2939
+ yield await importWithAlgCache(_cached, jwk, alg);
2940
+ } catch {}
2941
+ };
2942
+ throw error;
2943
+ }
2944
+ return importWithAlgCache(this._cached, jwk, alg);
2945
+ }
2946
+ };
2947
+ async function importWithAlgCache(cache, jwk, alg) {
2948
+ const cached = cache.get(jwk) || cache.set(jwk, {}).get(jwk);
2949
+ if (cached[alg] === void 0) {
2950
+ const key = await (0, import_js_1.importJWK)({
2951
+ ...jwk,
2952
+ ext: true
2953
+ }, alg);
2954
+ if (key instanceof Uint8Array || key.type !== "public") throw new errors_js_1.JWKSInvalid("JSON Web Key Set members must be public keys");
2955
+ cached[alg] = key;
2956
+ }
2957
+ return cached[alg];
2958
+ }
2959
+ function createLocalJWKSet(jwks) {
2960
+ const set = new LocalJWKSet(jwks);
2961
+ const localJWKSet = async (protectedHeader, token) => set.getKey(protectedHeader, token);
2962
+ Object.defineProperties(localJWKSet, { jwks: {
2963
+ value: () => clone(set._jwks),
2964
+ enumerable: true,
2965
+ configurable: false,
2966
+ writable: false
2967
+ } });
2968
+ return localJWKSet;
2969
+ }
2970
+ }));
2971
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/fetch_jwks.js
2972
+ var require_fetch_jwks = /* @__PURE__ */ __commonJSMin(((exports) => {
2973
+ Object.defineProperty(exports, "__esModule", { value: true });
2974
+ var http = __require("node:http");
2975
+ var https = __require("node:https");
2976
+ var node_events_1 = __require("node:events");
2977
+ var errors_js_1 = require_errors();
2978
+ var buffer_utils_js_1 = require_buffer_utils();
2979
+ var fetchJwks = async (url, timeout, options) => {
2980
+ let get;
2981
+ switch (url.protocol) {
2982
+ case "https:":
2983
+ get = https.get;
2984
+ break;
2985
+ case "http:":
2986
+ get = http.get;
2987
+ break;
2988
+ default: throw new TypeError("Unsupported URL protocol.");
2989
+ }
2990
+ const { agent, headers } = options;
2991
+ const req = get(url.href, {
2992
+ agent,
2993
+ timeout,
2994
+ headers
2995
+ });
2996
+ const [response] = await Promise.race([(0, node_events_1.once)(req, "response"), (0, node_events_1.once)(req, "timeout")]);
2997
+ if (!response) {
2998
+ req.destroy();
2999
+ throw new errors_js_1.JWKSTimeout();
3000
+ }
3001
+ if (response.statusCode !== 200) throw new errors_js_1.JOSEError("Expected 200 OK from the JSON Web Key Set HTTP response");
3002
+ const parts = [];
3003
+ for await (const part of response) parts.push(part);
3004
+ try {
3005
+ return JSON.parse(buffer_utils_js_1.decoder.decode((0, buffer_utils_js_1.concat)(...parts)));
3006
+ } catch {
3007
+ throw new errors_js_1.JOSEError("Failed to parse the JSON Web Key Set HTTP response as JSON");
3008
+ }
3009
+ };
3010
+ exports.default = fetchJwks;
3011
+ }));
3012
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwks/remote.js
3013
+ var require_remote = /* @__PURE__ */ __commonJSMin(((exports) => {
3014
+ Object.defineProperty(exports, "__esModule", { value: true });
3015
+ exports.experimental_jwksCache = exports.jwksCache = void 0;
3016
+ exports.createRemoteJWKSet = createRemoteJWKSet;
3017
+ var fetch_jwks_js_1 = require_fetch_jwks();
3018
+ var errors_js_1 = require_errors();
3019
+ var local_js_1 = require_local();
3020
+ var is_object_js_1 = require_is_object();
3021
+ function isCloudflareWorkers() {
3022
+ return typeof WebSocketPair !== "undefined" || typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers" || typeof EdgeRuntime !== "undefined" && EdgeRuntime === "vercel";
3023
+ }
3024
+ var USER_AGENT;
3025
+ if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) USER_AGENT = `jose/v5.10.0`;
3026
+ exports.jwksCache = Symbol();
3027
+ function isFreshJwksCache(input, cacheMaxAge) {
3028
+ if (typeof input !== "object" || input === null) return false;
3029
+ if (!("uat" in input) || typeof input.uat !== "number" || Date.now() - input.uat >= cacheMaxAge) return false;
3030
+ if (!("jwks" in input) || !(0, is_object_js_1.default)(input.jwks) || !Array.isArray(input.jwks.keys) || !Array.prototype.every.call(input.jwks.keys, is_object_js_1.default)) return false;
3031
+ return true;
3032
+ }
3033
+ var RemoteJWKSet = class {
3034
+ _url;
3035
+ _timeoutDuration;
3036
+ _cooldownDuration;
3037
+ _cacheMaxAge;
3038
+ _jwksTimestamp;
3039
+ _pendingFetch;
3040
+ _options;
3041
+ _local;
3042
+ _cache;
3043
+ constructor(url, options) {
3044
+ if (!(url instanceof URL)) throw new TypeError("url must be an instance of URL");
3045
+ this._url = new URL(url.href);
3046
+ this._options = {
3047
+ agent: options?.agent,
3048
+ headers: options?.headers
3049
+ };
3050
+ this._timeoutDuration = typeof options?.timeoutDuration === "number" ? options?.timeoutDuration : 5e3;
3051
+ this._cooldownDuration = typeof options?.cooldownDuration === "number" ? options?.cooldownDuration : 3e4;
3052
+ this._cacheMaxAge = typeof options?.cacheMaxAge === "number" ? options?.cacheMaxAge : 6e5;
3053
+ if (options?.[exports.jwksCache] !== void 0) {
3054
+ this._cache = options?.[exports.jwksCache];
3055
+ if (isFreshJwksCache(options?.[exports.jwksCache], this._cacheMaxAge)) {
3056
+ this._jwksTimestamp = this._cache.uat;
3057
+ this._local = (0, local_js_1.createLocalJWKSet)(this._cache.jwks);
3058
+ }
3059
+ }
3060
+ }
3061
+ coolingDown() {
3062
+ return typeof this._jwksTimestamp === "number" ? Date.now() < this._jwksTimestamp + this._cooldownDuration : false;
3063
+ }
3064
+ fresh() {
3065
+ return typeof this._jwksTimestamp === "number" ? Date.now() < this._jwksTimestamp + this._cacheMaxAge : false;
3066
+ }
3067
+ async getKey(protectedHeader, token) {
3068
+ if (!this._local || !this.fresh()) await this.reload();
3069
+ try {
3070
+ return await this._local(protectedHeader, token);
3071
+ } catch (err) {
3072
+ if (err instanceof errors_js_1.JWKSNoMatchingKey) {
3073
+ if (this.coolingDown() === false) {
3074
+ await this.reload();
3075
+ return this._local(protectedHeader, token);
3076
+ }
3077
+ }
3078
+ throw err;
3079
+ }
3080
+ }
3081
+ async reload() {
3082
+ if (this._pendingFetch && isCloudflareWorkers()) this._pendingFetch = void 0;
3083
+ const headers = new Headers(this._options.headers);
3084
+ if (USER_AGENT && !headers.has("User-Agent")) {
3085
+ headers.set("User-Agent", USER_AGENT);
3086
+ this._options.headers = Object.fromEntries(headers.entries());
3087
+ }
3088
+ this._pendingFetch ||= (0, fetch_jwks_js_1.default)(this._url, this._timeoutDuration, this._options).then((json) => {
3089
+ this._local = (0, local_js_1.createLocalJWKSet)(json);
3090
+ if (this._cache) {
3091
+ this._cache.uat = Date.now();
3092
+ this._cache.jwks = json;
3093
+ }
3094
+ this._jwksTimestamp = Date.now();
3095
+ this._pendingFetch = void 0;
3096
+ }).catch((err) => {
3097
+ this._pendingFetch = void 0;
3098
+ throw err;
3099
+ });
3100
+ await this._pendingFetch;
3101
+ }
3102
+ };
3103
+ function createRemoteJWKSet(url, options) {
3104
+ const set = new RemoteJWKSet(url, options);
3105
+ const remoteJWKSet = async (protectedHeader, token) => set.getKey(protectedHeader, token);
3106
+ Object.defineProperties(remoteJWKSet, {
3107
+ coolingDown: {
3108
+ get: () => set.coolingDown(),
3109
+ enumerable: true,
3110
+ configurable: false
3111
+ },
3112
+ fresh: {
3113
+ get: () => set.fresh(),
3114
+ enumerable: true,
3115
+ configurable: false
3116
+ },
3117
+ reload: {
3118
+ value: () => set.reload(),
3119
+ enumerable: true,
3120
+ configurable: false,
3121
+ writable: false
3122
+ },
3123
+ reloading: {
3124
+ get: () => !!set._pendingFetch,
3125
+ enumerable: true,
3126
+ configurable: false
3127
+ },
3128
+ jwks: {
3129
+ value: () => set._local?.jwks(),
3130
+ enumerable: true,
3131
+ configurable: false,
3132
+ writable: false
3133
+ }
3134
+ });
3135
+ return remoteJWKSet;
3136
+ }
3137
+ exports.experimental_jwksCache = exports.jwksCache;
3138
+ }));
3139
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/jwt/unsecured.js
3140
+ var require_unsecured = /* @__PURE__ */ __commonJSMin(((exports) => {
3141
+ Object.defineProperty(exports, "__esModule", { value: true });
3142
+ exports.UnsecuredJWT = void 0;
3143
+ var base64url = require_base64url$1();
3144
+ var buffer_utils_js_1 = require_buffer_utils();
3145
+ var errors_js_1 = require_errors();
3146
+ var jwt_claims_set_js_1 = require_jwt_claims_set();
3147
+ var produce_js_1 = require_produce();
3148
+ var UnsecuredJWT = class extends produce_js_1.ProduceJWT {
3149
+ encode() {
3150
+ return `${base64url.encode(JSON.stringify({ alg: "none" }))}.${base64url.encode(JSON.stringify(this._payload))}.`;
3151
+ }
3152
+ static decode(jwt, options) {
3153
+ if (typeof jwt !== "string") throw new errors_js_1.JWTInvalid("Unsecured JWT must be a string");
3154
+ const { 0: encodedHeader, 1: encodedPayload, 2: signature, length } = jwt.split(".");
3155
+ if (length !== 3 || signature !== "") throw new errors_js_1.JWTInvalid("Invalid Unsecured JWT");
3156
+ let header;
3157
+ try {
3158
+ header = JSON.parse(buffer_utils_js_1.decoder.decode(base64url.decode(encodedHeader)));
3159
+ if (header.alg !== "none") throw new Error();
3160
+ } catch {
3161
+ throw new errors_js_1.JWTInvalid("Invalid Unsecured JWT");
3162
+ }
3163
+ return {
3164
+ payload: (0, jwt_claims_set_js_1.default)(header, base64url.decode(encodedPayload), options),
3165
+ header
3166
+ };
3167
+ }
3168
+ };
3169
+ exports.UnsecuredJWT = UnsecuredJWT;
3170
+ }));
3171
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/util/base64url.js
3172
+ var require_base64url = /* @__PURE__ */ __commonJSMin(((exports) => {
3173
+ Object.defineProperty(exports, "__esModule", { value: true });
3174
+ exports.decode = exports.encode = void 0;
3175
+ var base64url = require_base64url$1();
3176
+ exports.encode = base64url.encode;
3177
+ exports.decode = base64url.decode;
3178
+ }));
3179
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/util/decode_protected_header.js
3180
+ var require_decode_protected_header = /* @__PURE__ */ __commonJSMin(((exports) => {
3181
+ Object.defineProperty(exports, "__esModule", { value: true });
3182
+ exports.decodeProtectedHeader = decodeProtectedHeader;
3183
+ var base64url_js_1 = require_base64url();
3184
+ var buffer_utils_js_1 = require_buffer_utils();
3185
+ var is_object_js_1 = require_is_object();
3186
+ function decodeProtectedHeader(token) {
3187
+ let protectedB64u;
3188
+ if (typeof token === "string") {
3189
+ const parts = token.split(".");
3190
+ if (parts.length === 3 || parts.length === 5) [protectedB64u] = parts;
3191
+ } else if (typeof token === "object" && token) {
3192
+ if ("protected" in token) protectedB64u = token.protected;
3193
+ else throw new TypeError("Token does not contain a Protected Header");
3194
+ }
3195
+ try {
3196
+ if (typeof protectedB64u !== "string" || !protectedB64u) throw new Error();
3197
+ const result = JSON.parse(buffer_utils_js_1.decoder.decode((0, base64url_js_1.decode)(protectedB64u)));
3198
+ if (!(0, is_object_js_1.default)(result)) throw new Error();
3199
+ return result;
3200
+ } catch {
3201
+ throw new TypeError("Invalid Token or Protected Header formatting");
3202
+ }
3203
+ }
3204
+ }));
3205
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/util/decode_jwt.js
3206
+ var require_decode_jwt = /* @__PURE__ */ __commonJSMin(((exports) => {
3207
+ Object.defineProperty(exports, "__esModule", { value: true });
3208
+ exports.decodeJwt = decodeJwt;
3209
+ var base64url_js_1 = require_base64url();
3210
+ var buffer_utils_js_1 = require_buffer_utils();
3211
+ var is_object_js_1 = require_is_object();
3212
+ var errors_js_1 = require_errors();
3213
+ function decodeJwt(jwt) {
3214
+ if (typeof jwt !== "string") throw new errors_js_1.JWTInvalid("JWTs must use Compact JWS serialization, JWT must be a string");
3215
+ const { 1: payload, length } = jwt.split(".");
3216
+ if (length === 5) throw new errors_js_1.JWTInvalid("Only JWTs using Compact JWS serialization can be decoded");
3217
+ if (length !== 3) throw new errors_js_1.JWTInvalid("Invalid JWT");
3218
+ if (!payload) throw new errors_js_1.JWTInvalid("JWTs must contain a payload");
3219
+ let decoded;
3220
+ try {
3221
+ decoded = (0, base64url_js_1.decode)(payload);
3222
+ } catch {
3223
+ throw new errors_js_1.JWTInvalid("Failed to base64url decode the payload");
3224
+ }
3225
+ let result;
3226
+ try {
3227
+ result = JSON.parse(buffer_utils_js_1.decoder.decode(decoded));
3228
+ } catch {
3229
+ throw new errors_js_1.JWTInvalid("Failed to parse the decoded payload as JSON");
3230
+ }
3231
+ if (!(0, is_object_js_1.default)(result)) throw new errors_js_1.JWTInvalid("Invalid JWT Claims Set");
3232
+ return result;
3233
+ }
3234
+ }));
3235
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/generate.js
3236
+ var require_generate = /* @__PURE__ */ __commonJSMin(((exports) => {
3237
+ Object.defineProperty(exports, "__esModule", { value: true });
3238
+ exports.generateSecret = generateSecret;
3239
+ exports.generateKeyPair = generateKeyPair;
3240
+ var node_crypto_1 = __require("node:crypto");
3241
+ var node_util_1 = __require("node:util");
3242
+ var random_js_1 = require_random();
3243
+ var errors_js_1 = require_errors();
3244
+ var generate = (0, node_util_1.promisify)(node_crypto_1.generateKeyPair);
3245
+ async function generateSecret(alg, options) {
3246
+ let length;
3247
+ switch (alg) {
3248
+ case "HS256":
3249
+ case "HS384":
3250
+ case "HS512":
3251
+ case "A128CBC-HS256":
3252
+ case "A192CBC-HS384":
3253
+ case "A256CBC-HS512":
3254
+ length = parseInt(alg.slice(-3), 10);
3255
+ break;
3256
+ case "A128KW":
3257
+ case "A192KW":
3258
+ case "A256KW":
3259
+ case "A128GCMKW":
3260
+ case "A192GCMKW":
3261
+ case "A256GCMKW":
3262
+ case "A128GCM":
3263
+ case "A192GCM":
3264
+ case "A256GCM":
3265
+ length = parseInt(alg.slice(1, 4), 10);
3266
+ break;
3267
+ default: throw new errors_js_1.JOSENotSupported("Invalid or unsupported JWK \"alg\" (Algorithm) Parameter value");
3268
+ }
3269
+ return (0, node_crypto_1.createSecretKey)((0, random_js_1.default)(new Uint8Array(length >> 3)));
3270
+ }
3271
+ async function generateKeyPair(alg, options) {
3272
+ switch (alg) {
3273
+ case "RS256":
3274
+ case "RS384":
3275
+ case "RS512":
3276
+ case "PS256":
3277
+ case "PS384":
3278
+ case "PS512":
3279
+ case "RSA-OAEP":
3280
+ case "RSA-OAEP-256":
3281
+ case "RSA-OAEP-384":
3282
+ case "RSA-OAEP-512":
3283
+ case "RSA1_5": {
3284
+ const modulusLength = options?.modulusLength ?? 2048;
3285
+ if (typeof modulusLength !== "number" || modulusLength < 2048) throw new errors_js_1.JOSENotSupported("Invalid or unsupported modulusLength option provided, 2048 bits or larger keys must be used");
3286
+ return await generate("rsa", {
3287
+ modulusLength,
3288
+ publicExponent: 65537
3289
+ });
3290
+ }
3291
+ case "ES256": return generate("ec", { namedCurve: "P-256" });
3292
+ case "ES256K": return generate("ec", { namedCurve: "secp256k1" });
3293
+ case "ES384": return generate("ec", { namedCurve: "P-384" });
3294
+ case "ES512": return generate("ec", { namedCurve: "P-521" });
3295
+ case "Ed25519": return generate("ed25519");
3296
+ case "EdDSA": switch (options?.crv) {
3297
+ case void 0:
3298
+ case "Ed25519": return generate("ed25519");
3299
+ case "Ed448": return generate("ed448");
3300
+ default: throw new errors_js_1.JOSENotSupported("Invalid or unsupported crv option provided, supported values are Ed25519 and Ed448");
3301
+ }
3302
+ case "ECDH-ES":
3303
+ case "ECDH-ES+A128KW":
3304
+ case "ECDH-ES+A192KW":
3305
+ case "ECDH-ES+A256KW": {
3306
+ const crv = options?.crv ?? "P-256";
3307
+ switch (crv) {
3308
+ case void 0:
3309
+ case "P-256":
3310
+ case "P-384":
3311
+ case "P-521": return generate("ec", { namedCurve: crv });
3312
+ case "X25519": return generate("x25519");
3313
+ case "X448": return generate("x448");
3314
+ default: throw new errors_js_1.JOSENotSupported("Invalid or unsupported crv option provided, supported values are P-256, P-384, P-521, X25519, and X448");
3315
+ }
3316
+ }
3317
+ default: throw new errors_js_1.JOSENotSupported("Invalid or unsupported JWK \"alg\" (Algorithm) Parameter value");
3318
+ }
3319
+ }
3320
+ }));
3321
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/key/generate_key_pair.js
3322
+ var require_generate_key_pair = /* @__PURE__ */ __commonJSMin(((exports) => {
3323
+ Object.defineProperty(exports, "__esModule", { value: true });
3324
+ exports.generateKeyPair = generateKeyPair;
3325
+ var generate_js_1 = require_generate();
3326
+ async function generateKeyPair(alg, options) {
3327
+ return (0, generate_js_1.generateKeyPair)(alg, options);
3328
+ }
3329
+ }));
3330
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/key/generate_secret.js
3331
+ var require_generate_secret = /* @__PURE__ */ __commonJSMin(((exports) => {
3332
+ Object.defineProperty(exports, "__esModule", { value: true });
3333
+ exports.generateSecret = generateSecret;
3334
+ var generate_js_1 = require_generate();
3335
+ async function generateSecret(alg, options) {
3336
+ return (0, generate_js_1.generateSecret)(alg, options);
3337
+ }
3338
+ }));
3339
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/runtime/runtime.js
3340
+ var require_runtime$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
3341
+ Object.defineProperty(exports, "__esModule", { value: true });
3342
+ exports.default = "node:crypto";
3343
+ }));
3344
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/util/runtime.js
3345
+ var require_runtime = /* @__PURE__ */ __commonJSMin(((exports) => {
3346
+ Object.defineProperty(exports, "__esModule", { value: true });
3347
+ exports.default = require_runtime$1().default;
3348
+ }));
3349
+ // ../../node_modules/.bun/jose@5.10.0/node_modules/jose/dist/node/cjs/index.js
3350
+ var require_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
3351
+ Object.defineProperty(exports, "__esModule", { value: true });
3352
+ exports.cryptoRuntime = exports.base64url = exports.generateSecret = exports.generateKeyPair = exports.errors = exports.decodeJwt = exports.decodeProtectedHeader = exports.importJWK = exports.importX509 = exports.importPKCS8 = exports.importSPKI = exports.exportJWK = exports.exportSPKI = exports.exportPKCS8 = exports.UnsecuredJWT = exports.experimental_jwksCache = exports.jwksCache = exports.createRemoteJWKSet = exports.createLocalJWKSet = exports.EmbeddedJWK = exports.calculateJwkThumbprintUri = exports.calculateJwkThumbprint = exports.EncryptJWT = exports.SignJWT = exports.GeneralSign = exports.FlattenedSign = exports.CompactSign = exports.FlattenedEncrypt = exports.CompactEncrypt = exports.jwtDecrypt = exports.jwtVerify = exports.generalVerify = exports.flattenedVerify = exports.compactVerify = exports.GeneralEncrypt = exports.generalDecrypt = exports.flattenedDecrypt = exports.compactDecrypt = void 0;
3353
+ var decrypt_js_1 = require_decrypt$2();
3354
+ Object.defineProperty(exports, "compactDecrypt", {
3355
+ enumerable: true,
3356
+ get: function() {
3357
+ return decrypt_js_1.compactDecrypt;
3358
+ }
3359
+ });
3360
+ var decrypt_js_2 = require_decrypt$3();
3361
+ Object.defineProperty(exports, "flattenedDecrypt", {
3362
+ enumerable: true,
3363
+ get: function() {
3364
+ return decrypt_js_2.flattenedDecrypt;
3365
+ }
3366
+ });
3367
+ var decrypt_js_3 = require_decrypt$1();
3368
+ Object.defineProperty(exports, "generalDecrypt", {
3369
+ enumerable: true,
3370
+ get: function() {
3371
+ return decrypt_js_3.generalDecrypt;
3372
+ }
3373
+ });
3374
+ var encrypt_js_1 = require_encrypt$2();
3375
+ Object.defineProperty(exports, "GeneralEncrypt", {
3376
+ enumerable: true,
3377
+ get: function() {
3378
+ return encrypt_js_1.GeneralEncrypt;
3379
+ }
3380
+ });
3381
+ var verify_js_1 = require_verify$2();
3382
+ Object.defineProperty(exports, "compactVerify", {
3383
+ enumerable: true,
3384
+ get: function() {
3385
+ return verify_js_1.compactVerify;
3386
+ }
3387
+ });
3388
+ var verify_js_2 = require_verify$3();
3389
+ Object.defineProperty(exports, "flattenedVerify", {
3390
+ enumerable: true,
3391
+ get: function() {
3392
+ return verify_js_2.flattenedVerify;
3393
+ }
3394
+ });
3395
+ var verify_js_3 = require_verify$1();
3396
+ Object.defineProperty(exports, "generalVerify", {
3397
+ enumerable: true,
3398
+ get: function() {
3399
+ return verify_js_3.generalVerify;
3400
+ }
3401
+ });
3402
+ var verify_js_4 = require_verify();
3403
+ Object.defineProperty(exports, "jwtVerify", {
3404
+ enumerable: true,
3405
+ get: function() {
3406
+ return verify_js_4.jwtVerify;
3407
+ }
3408
+ });
3409
+ var decrypt_js_4 = require_decrypt();
3410
+ Object.defineProperty(exports, "jwtDecrypt", {
3411
+ enumerable: true,
3412
+ get: function() {
3413
+ return decrypt_js_4.jwtDecrypt;
3414
+ }
3415
+ });
3416
+ var encrypt_js_2 = require_encrypt$1();
3417
+ Object.defineProperty(exports, "CompactEncrypt", {
3418
+ enumerable: true,
3419
+ get: function() {
3420
+ return encrypt_js_2.CompactEncrypt;
3421
+ }
3422
+ });
3423
+ var encrypt_js_3 = require_encrypt$3();
3424
+ Object.defineProperty(exports, "FlattenedEncrypt", {
3425
+ enumerable: true,
3426
+ get: function() {
3427
+ return encrypt_js_3.FlattenedEncrypt;
3428
+ }
3429
+ });
3430
+ var sign_js_1 = require_sign$2();
3431
+ Object.defineProperty(exports, "CompactSign", {
3432
+ enumerable: true,
3433
+ get: function() {
3434
+ return sign_js_1.CompactSign;
3435
+ }
3436
+ });
3437
+ var sign_js_2 = require_sign$3();
3438
+ Object.defineProperty(exports, "FlattenedSign", {
3439
+ enumerable: true,
3440
+ get: function() {
3441
+ return sign_js_2.FlattenedSign;
3442
+ }
3443
+ });
3444
+ var sign_js_3 = require_sign$1();
3445
+ Object.defineProperty(exports, "GeneralSign", {
3446
+ enumerable: true,
3447
+ get: function() {
3448
+ return sign_js_3.GeneralSign;
3449
+ }
3450
+ });
3451
+ var sign_js_4 = require_sign();
3452
+ Object.defineProperty(exports, "SignJWT", {
3453
+ enumerable: true,
3454
+ get: function() {
3455
+ return sign_js_4.SignJWT;
3456
+ }
3457
+ });
3458
+ var encrypt_js_4 = require_encrypt();
3459
+ Object.defineProperty(exports, "EncryptJWT", {
3460
+ enumerable: true,
3461
+ get: function() {
3462
+ return encrypt_js_4.EncryptJWT;
3463
+ }
3464
+ });
3465
+ var thumbprint_js_1 = require_thumbprint();
3466
+ Object.defineProperty(exports, "calculateJwkThumbprint", {
3467
+ enumerable: true,
3468
+ get: function() {
3469
+ return thumbprint_js_1.calculateJwkThumbprint;
3470
+ }
3471
+ });
3472
+ Object.defineProperty(exports, "calculateJwkThumbprintUri", {
3473
+ enumerable: true,
3474
+ get: function() {
3475
+ return thumbprint_js_1.calculateJwkThumbprintUri;
3476
+ }
3477
+ });
3478
+ var embedded_js_1 = require_embedded();
3479
+ Object.defineProperty(exports, "EmbeddedJWK", {
3480
+ enumerable: true,
3481
+ get: function() {
3482
+ return embedded_js_1.EmbeddedJWK;
3483
+ }
3484
+ });
3485
+ var local_js_1 = require_local();
3486
+ Object.defineProperty(exports, "createLocalJWKSet", {
3487
+ enumerable: true,
3488
+ get: function() {
3489
+ return local_js_1.createLocalJWKSet;
3490
+ }
3491
+ });
3492
+ var remote_js_1 = require_remote();
3493
+ Object.defineProperty(exports, "createRemoteJWKSet", {
3494
+ enumerable: true,
3495
+ get: function() {
3496
+ return remote_js_1.createRemoteJWKSet;
3497
+ }
3498
+ });
3499
+ Object.defineProperty(exports, "jwksCache", {
3500
+ enumerable: true,
3501
+ get: function() {
3502
+ return remote_js_1.jwksCache;
3503
+ }
3504
+ });
3505
+ Object.defineProperty(exports, "experimental_jwksCache", {
3506
+ enumerable: true,
3507
+ get: function() {
3508
+ return remote_js_1.experimental_jwksCache;
3509
+ }
3510
+ });
3511
+ var unsecured_js_1 = require_unsecured();
3512
+ Object.defineProperty(exports, "UnsecuredJWT", {
3513
+ enumerable: true,
3514
+ get: function() {
3515
+ return unsecured_js_1.UnsecuredJWT;
3516
+ }
3517
+ });
3518
+ var export_js_1 = require_export();
3519
+ Object.defineProperty(exports, "exportPKCS8", {
3520
+ enumerable: true,
3521
+ get: function() {
3522
+ return export_js_1.exportPKCS8;
3523
+ }
3524
+ });
3525
+ Object.defineProperty(exports, "exportSPKI", {
3526
+ enumerable: true,
3527
+ get: function() {
3528
+ return export_js_1.exportSPKI;
3529
+ }
3530
+ });
3531
+ Object.defineProperty(exports, "exportJWK", {
3532
+ enumerable: true,
3533
+ get: function() {
3534
+ return export_js_1.exportJWK;
3535
+ }
3536
+ });
3537
+ var import_js_1 = require_import();
3538
+ Object.defineProperty(exports, "importSPKI", {
3539
+ enumerable: true,
3540
+ get: function() {
3541
+ return import_js_1.importSPKI;
3542
+ }
3543
+ });
3544
+ Object.defineProperty(exports, "importPKCS8", {
3545
+ enumerable: true,
3546
+ get: function() {
3547
+ return import_js_1.importPKCS8;
3548
+ }
3549
+ });
3550
+ Object.defineProperty(exports, "importX509", {
3551
+ enumerable: true,
3552
+ get: function() {
3553
+ return import_js_1.importX509;
3554
+ }
3555
+ });
3556
+ Object.defineProperty(exports, "importJWK", {
3557
+ enumerable: true,
3558
+ get: function() {
3559
+ return import_js_1.importJWK;
3560
+ }
3561
+ });
3562
+ var decode_protected_header_js_1 = require_decode_protected_header();
3563
+ Object.defineProperty(exports, "decodeProtectedHeader", {
3564
+ enumerable: true,
3565
+ get: function() {
3566
+ return decode_protected_header_js_1.decodeProtectedHeader;
3567
+ }
3568
+ });
3569
+ var decode_jwt_js_1 = require_decode_jwt();
3570
+ Object.defineProperty(exports, "decodeJwt", {
3571
+ enumerable: true,
3572
+ get: function() {
3573
+ return decode_jwt_js_1.decodeJwt;
3574
+ }
3575
+ });
3576
+ exports.errors = require_errors();
3577
+ var generate_key_pair_js_1 = require_generate_key_pair();
3578
+ Object.defineProperty(exports, "generateKeyPair", {
3579
+ enumerable: true,
3580
+ get: function() {
3581
+ return generate_key_pair_js_1.generateKeyPair;
3582
+ }
3583
+ });
3584
+ var generate_secret_js_1 = require_generate_secret();
3585
+ Object.defineProperty(exports, "generateSecret", {
3586
+ enumerable: true,
3587
+ get: function() {
3588
+ return generate_secret_js_1.generateSecret;
3589
+ }
3590
+ });
3591
+ exports.base64url = require_base64url();
3592
+ var runtime_js_1 = require_runtime();
3593
+ Object.defineProperty(exports, "cryptoRuntime", {
3594
+ enumerable: true,
3595
+ get: function() {
3596
+ return runtime_js_1.default;
3597
+ }
3598
+ });
3599
+ }));
3600
+ export { require_cjs as t };