@milkio/stargate 1.3.70 → 1.3.72

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 (3) hide show
  1. package/index.d.ts +92 -19
  2. package/index.js +859 -724
  3. package/package.json +1 -1
package/index.js CHANGED
@@ -1,748 +1,883 @@
1
1
  // packages/milkio-stargate/index.ts
2
+ function createFail(code, data) {
3
+ return {
4
+ $milkioFailure: true,
5
+ kind: "fail",
6
+ code,
7
+ data
8
+ };
9
+ }
10
+ function createFault(code, data) {
11
+ return {
12
+ $milkioFailure: true,
13
+ kind: "fault",
14
+ code,
15
+ data
16
+ };
17
+ }
18
+ function createNetworkFailure() {
19
+ return {
20
+ $milkioFailure: true,
21
+ kind: "fault",
22
+ code: "NETWORK_ERROR"
23
+ };
24
+ }
25
+ function createTimeoutFailure(timeout) {
26
+ return {
27
+ $milkioFailure: true,
28
+ kind: "fault",
29
+ code: "REQUEST_TIMEOUT",
30
+ data: {
31
+ timeout,
32
+ message: `Execute timeout after ${timeout}ms.`
33
+ }
34
+ };
35
+ }
36
+ /** only transport-level faults are retried; fail and server faults are never retried */
37
+ function isTransportFailure(failure) {
38
+ return failure.kind === "fault" && (failure.code === "NETWORK_ERROR" || failure.code === "REQUEST_TIMEOUT");
39
+ }
40
+ /** restore a wire failure: fail keeps code/data, fault is always reduced to the generic code by the server */
41
+ function reviveFailureWire(wire) {
42
+ if (typeof wire === "object" && wire !== null) {
43
+ const parsed = wire;
44
+ if (parsed.kind === "fail" && typeof parsed.code === "string") return createFail(parsed.code, parsed.data);
45
+ if (parsed.kind === "fault") return createFault("INTERNAL_SERVER_ERROR");
46
+ }
47
+ return createFault("INTERNAL_SERVER_ERROR");
48
+ }
2
49
  async function createStargate(stargateOptions) {
3
- const $fetch = stargateOptions.fetch ?? fetch;
4
- const $abort = stargateOptions.abort ?? AbortController;
5
- const handleError = async (error, key, handler) => {
6
- if (key in error) {
7
- const handled = await handler(error[key]);
8
- if (handled)
9
- delete error[key];
10
- }
11
- };
12
- const __initEventManager = () => {
13
- const handlers = new Map;
14
- const indexed = new Map;
15
- const eventManager = {
16
- on: (key, handler) => {
17
- handlers.set(handler, key);
18
- if (indexed.has(key) === false) {
19
- indexed.set(key, new Set);
20
- }
21
- const set = indexed.get(key);
22
- set.add(handler);
23
- handlers.set(handler, key);
24
- return () => {
25
- handlers.delete(handler);
26
- set.delete(handler);
27
- };
28
- },
29
- off: (key, handler) => {
30
- const set = indexed.get(key);
31
- if (!set)
32
- return;
33
- handlers.delete(handler);
34
- set.delete(handler);
35
- },
36
- emit: async (key, value) => {
37
- const h = indexed.get(key);
38
- if (h) {
39
- for (const handler of h) {
40
- await handler(value);
41
- }
42
- }
43
- }
44
- };
45
- return eventManager;
46
- };
47
- const eventManager = __initEventManager();
48
- const bootstrap = async () => {
49
- let baseUrl = stargateOptions.baseUrl;
50
- if (typeof baseUrl === "function")
51
- baseUrl = await baseUrl();
52
- if (baseUrl.endsWith("/"))
53
- baseUrl = baseUrl.slice(0, -1);
54
- return baseUrl;
55
- };
56
- const baseUrlPromise = bootstrap();
57
- let resolvedBaseUrl = null;
58
- let cachedUrlPath = null;
59
- let cachedUrl = null;
60
- const stargate = {
61
- ...eventManager,
62
- options: stargateOptions,
63
- async execute(path, options) {
64
- if (options.headers === undefined)
65
- options.headers = {};
66
- let url;
67
- if (options.baseUrl) {
68
- let baseUrl = options.baseUrl;
69
- if (typeof baseUrl === "function")
70
- baseUrl = await baseUrl();
71
- if (baseUrl.endsWith("/"))
72
- baseUrl = baseUrl.slice(0, -1);
73
- url = baseUrl + path;
74
- } else {
75
- if (!resolvedBaseUrl)
76
- resolvedBaseUrl = await baseUrlPromise;
77
- if (path === cachedUrlPath && cachedUrl !== null) {
78
- url = cachedUrl;
79
- } else {
80
- url = resolvedBaseUrl + path;
81
- cachedUrlPath = path;
82
- cachedUrl = url;
83
- }
84
- }
85
- if (!path.endsWith("~")) {
86
- const h = options.headers;
87
- if (h.Accept === undefined)
88
- h.Accept = "application/json";
89
- if (h["Content-Type"] === undefined)
90
- h["Content-Type"] = "application/json";
91
- const cacheStrategy = options.cacheStrategy ?? "off";
92
- let retryCount = 0;
93
- if (options.retryStrategy === true || options.retryStrategy === 2) {
94
- retryCount = 2;
95
- } else if (typeof options.retryStrategy === "number" && options.retryStrategy > 0) {
96
- retryCount = options.retryStrategy;
97
- }
98
- if (cacheStrategy === "off" && retryCount === 0) {
99
- try {
100
- await eventManager.emit("milkio:executeBefore", { path, options });
101
- const body = JSON.stringify(options.params) ?? "";
102
- await eventManager.emit("milkio:fetchBefore", { path, options, body });
103
- let text;
104
- const response = await $fetch(url, { method: "POST", body, headers: options.headers });
105
- text = await response.text();
106
- const parsed = reviveJSONParse(JSON.parse(text));
107
- if (parsed.success !== true) {
108
- const err = {};
109
- err[parsed.code] = parsed.reject ?? null;
110
- return [err, null, { executeId: parsed.executeId }];
111
- }
112
- return [null, parsed.data, { executeId: parsed.executeId }];
113
- } catch (error) {
114
- if (error?.[0]?.REQUEST_TIMEOUT) {
115
- return [error, null, { executeId: "" }];
116
- }
117
- const errorPined = { REQUEST_FAIL: error };
118
- return [errorPined, null, { executeId: "unknown" }];
119
- }
120
- }
121
- const cacheThrottleMs = options.cacheThrottleMs ?? 0;
122
- const cacheKey = generateCacheKey(path, options.params);
123
- let cacheStorage = stargateOptions.cacheStorage;
124
- if (cacheStrategy !== "off" && !cacheStorage) {
125
- cacheStorage = await createDefaultCacheStorage({ encryption: stargateOptions.cacheEncryption });
126
- }
127
- if (cacheStrategy !== "off" && cacheStorage && options.onCacheHit) {
128
- const cached = await cacheStorage.get(cacheKey);
129
- if (cached) {
130
- try {
131
- await options.onCacheHit(cached.data);
132
- } catch {}
133
- }
134
- }
135
- if (cacheStrategy === "throttle" && cacheStorage) {
136
- const cached = await cacheStorage.get(cacheKey);
137
- if (cached && Date.now() - cached.timestamp < cacheThrottleMs) {
138
- return [null, cached.data, { executeId: "cached" }];
139
- }
140
- }
141
- await eventManager.emit("milkio:executeBefore", { path, options });
142
- const body = JSON.stringify(options.params) ?? "";
143
- await eventManager.emit("milkio:fetchBefore", { path, options, body });
144
- const executeRequest = async (isRetry) => {
145
- try {
146
- const response = await $fetch(url, { method: "POST", body, headers: options.headers });
147
- const text = await response.text();
148
- const parsed = JSON.parse(text);
149
- return { result: { value: parsed }, error: null, isNetworkError: false };
150
- } catch (error) {
151
- const isNetworkError = !error?.[0]?.REQUEST_TIMEOUT;
152
- return { result: null, error, isNetworkError };
153
- }
154
- };
155
- let { result, error, isNetworkError } = await executeRequest(false);
156
- for (let retryIndex = 0;retryIndex < retryCount && error && isNetworkError; retryIndex++) {
157
- if (retryIndex > 0) {
158
- await new Promise((resolve) => setTimeout(resolve, 500));
159
- }
160
- const retryResult = await executeRequest(true);
161
- result = retryResult.result;
162
- error = retryResult.error;
163
- isNetworkError = retryResult.isNetworkError;
164
- }
165
- if (error) {
166
- if (error?.[0]?.REQUEST_TIMEOUT) {
167
- await eventManager.emit("milkio:executeError", { handleError, path, options, error });
168
- return error;
169
- }
170
- if (cacheStrategy !== "off" && cacheStorage && isNetworkError) {
171
- const cached = await cacheStorage.get(cacheKey);
172
- if (cached) {
173
- return [null, cached.data, { executeId: "cached" }];
174
- }
175
- }
176
- const errorPined = { REQUEST_FAIL: error };
177
- await eventManager.emit("milkio:executeError", { handleError, path, options, error: errorPined });
178
- return [errorPined, null, { executeId: "unknown" }];
179
- }
180
- if (result.value.success !== true) {
181
- const err = {};
182
- err[result.value.code] = result.value.reject ?? null;
183
- await eventManager.emit("milkio:executeError", { handleError, path, options, error: err });
184
- return [err, null, { executeId: result.value.executeId }];
185
- }
186
- if (cacheStrategy !== "off" && cacheStorage) {
187
- await cacheStorage.set(cacheKey, result.value.data);
188
- }
189
- return [null, result.value.data, { executeId: result.value.executeId }];
190
- } else {
191
- options.cacheStrategy = "off";
192
- options.onCacheHit = undefined;
193
- options.cacheThrottleMs = undefined;
194
- if (options.headers.Accept === undefined)
195
- options.headers.Accept = "text/event-stream";
196
- if (options.headers["Content-Type"] === undefined)
197
- options.headers["Content-Type"] = "application/json";
198
- const stacks = new Map;
199
- let stacksIndex = 0;
200
- let iteratorIndex = 0;
201
- let streamResult;
202
- const streamResultFetched = withResolvers();
203
- const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;
204
- const timer = setTimeout(() => {
205
- streamResultFetched.reject([{ REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } }, null, { executeId: "unknown" }]);
206
- }, timeout);
207
- const onmessage = (event) => {
208
- if (event.data.startsWith("@")) {
209
- try {
210
- streamResult = reviveJSONParse(JSON.parse(event.data.slice(1)));
211
- streamResultFetched.resolve(undefined);
212
- clearTimeout(timer);
213
- } catch (error) {
214
- streamResultFetched.reject([{ REQUEST_FAIL: error }, null, { executeId: "unknown" }]);
215
- clearTimeout(timer);
216
- }
217
- } else {
218
- const index = ++stacksIndex;
219
- if (stacks.has(index)) {
220
- const stack = stacks.get(index);
221
- stack.done = true;
222
- stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });
223
- } else {
224
- const stack = withResolvers();
225
- stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });
226
- stacks.set(index, { ...stack, done: false });
227
- }
228
- }
229
- };
230
- let curRequestController;
231
- async function create() {
232
- curRequestController = new $abort;
233
- curRequestController.signal.addEventListener("abort", () => {
234
- iterator.return();
235
- });
236
- try {
237
- await eventManager.emit("milkio:executeBefore", { path, options });
238
- const body = JSON.stringify(options.params) ?? "";
239
- await eventManager.emit("milkio:fetchBefore", { path, options, body });
240
- const response = await $fetch(url, {
241
- method: "POST",
242
- headers: options.headers,
243
- body,
244
- signal: curRequestController.signal
245
- });
246
- const contentType = response.headers.get("Content-Type");
247
- if (!contentType?.startsWith("text/event-stream")) {
248
- throw new Error(`Expected content-type to be ${"text/event-stream"}, Actual: ${contentType}`);
249
- }
250
- await getBytes(response.body, getLines(getMessages(onmessage)));
251
- await iterator.return();
252
- } catch (err) {
253
- if (!curRequestController.signal.aborted)
254
- curRequestController.abort();
255
- const error = { REQUEST_FAIL: err };
256
- await eventManager.emit("milkio:executeError", { handleError, path, options, error });
257
- await iterator.throw(err);
258
- streamResultFetched.reject([error, null, { executeId: "unknown" }]);
259
- }
260
- }
261
- create();
262
- const iterator = {
263
- ...{
264
- next() {
265
- const index = ++iteratorIndex;
266
- if (stacks.has(index - 2))
267
- stacks.delete(index - 2);
268
- if (!stacks.has(index) && !curRequestController.signal.aborted) {
269
- const stack = withResolvers();
270
- stacks.set(index, { ...stack, done: false });
271
- return stack.promise;
272
- }
273
- if (!stacks.has(index) && curRequestController.signal.aborted) {
274
- const stack = withResolvers();
275
- stack.resolve({ done: true, value: undefined });
276
- return stack.promise;
277
- }
278
- return stacks.get(index).promise;
279
- },
280
- async return() {
281
- if (!curRequestController.signal.aborted)
282
- curRequestController.abort();
283
- for (const [_, iterator] of stacks)
284
- iterator.resolve({ done: true, value: undefined });
285
- return { done: true, value: undefined };
286
- },
287
- async throw(err) {
288
- streamResult = {
289
- success: false,
290
- executeId: streamResult?.executeId ?? "",
291
- fail: {
292
- code: "NETWORK_ERROR",
293
- message: "Network Error",
294
- fromClient: true,
295
- data: err
296
- }
297
- };
298
- for (const [_index, stack] of stacks) {
299
- if (stack.done)
300
- continue;
301
- stack.done = true;
302
- stack.resolve({ done: true, value: undefined });
303
- }
304
- if (!curRequestController.signal.aborted)
305
- curRequestController.abort();
306
- for (const [_, iterator] of stacks)
307
- iterator.resolve({ done: true, value: undefined });
308
- return { done: true, value: undefined };
309
- }
310
- },
311
- [Symbol.asyncIterator]() {
312
- return this;
313
- }
314
- };
315
- try {
316
- await streamResultFetched.promise;
317
- return [null, iterator, { executeId: streamResult.executeId }];
318
- } catch (error) {
319
- return error;
320
- }
321
- }
322
- },
323
- __cookbook: {
324
- subscribe: async (baseUrl) => {
325
- const headers = {
326
- "Content-Type": "application/json",
327
- Accept: "text/event-stream"
328
- };
329
- const params = {};
330
- const body = JSON.stringify(params) ?? "";
331
- const stacks = new Map;
332
- let stacksIndex = 0;
333
- let iteratorIndex = 0;
334
- const onmessage = (event) => {
335
- const index = ++stacksIndex;
336
- if (stacks.has(index)) {
337
- const stack = stacks.get(index);
338
- stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });
339
- } else {
340
- const stack = withResolvers();
341
- stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });
342
- stacks.set(index, { ...stack, done: false });
343
- }
344
- };
345
- let curRequestController;
346
- async function create() {
347
- curRequestController = new $abort;
348
- curRequestController.signal.addEventListener("abort", () => {
349
- iterator.return();
350
- });
351
- try {
352
- const response = await $fetch(`${baseUrl}/$subscribe`, {
353
- method: "POST",
354
- headers,
355
- body,
356
- signal: curRequestController.signal
357
- });
358
- const contentType = response.headers.get("Content-Type");
359
- if (!contentType?.startsWith("text/event-stream")) {
360
- throw new Error(`Expected content-type to be ${"text/event-stream"}, Actual: ${contentType}`);
361
- }
362
- await getBytes(response.body, getLines(getMessages(onmessage)));
363
- await iterator.return();
364
- } catch (err) {
365
- if (!curRequestController.signal.aborted)
366
- curRequestController.abort();
367
- await iterator.throw(err);
368
- }
369
- }
370
- create();
371
- const iterator = {
372
- ...{
373
- next() {
374
- const index = ++iteratorIndex;
375
- if (stacks.has(index - 2))
376
- stacks.delete(index - 2);
377
- if (!stacks.has(index) && !curRequestController.signal.aborted) {
378
- const stack = withResolvers();
379
- stacks.set(index, { ...stack, done: false });
380
- return stack.promise;
381
- }
382
- if (!stacks.has(index) && curRequestController.signal.aborted) {
383
- const stack = withResolvers();
384
- stack.resolve({ done: true, value: undefined });
385
- return stack.promise;
386
- }
387
- return stacks.get(index).promise;
388
- },
389
- async return() {
390
- if (!curRequestController.signal.aborted)
391
- curRequestController.abort();
392
- for (const [_, iterator] of stacks)
393
- iterator.resolve({ done: true, value: undefined });
394
- return { done: true, value: undefined };
395
- },
396
- async throw(err) {
397
- if (!curRequestController.signal.aborted)
398
- curRequestController.abort();
399
- for (const [_, iterator] of stacks)
400
- iterator.resolve({ done: true, value: undefined });
401
- return { done: true, value: undefined };
402
- }
403
- },
404
- [Symbol.asyncIterator]() {
405
- return this;
406
- }
407
- };
408
- try {
409
- return iterator;
410
- } catch (error) {
411
- return error;
412
- }
413
- }
414
- },
415
- __astraEmitEvent: async (key, options) => {
416
- const opts = options ?? {};
417
- if (opts.headers === undefined)
418
- opts.headers = {};
419
- if (opts.headers["Content-Type"] === undefined)
420
- opts.headers["Content-Type"] = "application/json";
421
- let url;
422
- if (!resolvedBaseUrl)
423
- resolvedBaseUrl = await baseUrlPromise;
424
- let base64Name;
425
- if (typeof btoa !== "undefined") {
426
- base64Name = btoa(key);
427
- } else if (typeof Buffer !== "undefined") {
428
- base64Name = Buffer.from(key).toString("base64");
429
- } else {
430
- throw new Error("No base64 encoder available");
431
- }
432
- url = `${resolvedBaseUrl}/$event/${encodeURIComponent(base64Name)}`;
433
- try {
434
- const body = JSON.stringify(opts.params) ?? "";
435
- const response = await $fetch(url, { method: "POST", body, headers: opts.headers });
436
- const text = await response.text();
437
- const parsed = reviveJSONParse(JSON.parse(text));
438
- if (parsed.success !== true) {
439
- const err = {};
440
- err[parsed.code] = parsed.reject ?? null;
441
- return [err, null, { executeId: parsed.executeId }];
442
- }
443
- return [null, parsed.data, { executeId: parsed.executeId }];
444
- } catch (error) {
445
- const errorPined = { REQUEST_FAIL: error };
446
- return [errorPined, null, { executeId: "unknown" }];
447
- }
448
- },
449
- async ping(options) {
450
- return await new Promise(async (resolve) => {
451
- const url = `${await baseUrlPromise}/generate_204`;
452
- const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;
453
- const startsTime = Date.now();
454
- const timer = setTimeout(() => {
455
- const endsTime = Date.now();
456
- resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } } }, null]);
457
- }, timeout);
458
- try {
459
- const response = await $fetch(url, { method: "HEAD" });
460
- const endsTime = Date.now();
461
- clearTimeout(timer);
462
- if (response.status !== 204) {
463
- resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_FAIL: { response, status: response.status, message: "Status code not 204" } } }, null]);
464
- }
465
- resolve([null, { connect: true, delay: endsTime - startsTime, serverTimestamp: Number(response.headers.get("Content-Type").substring(17)) }]);
466
- } catch (error) {
467
- const endsTime = Date.now();
468
- return [{ connect: false, delay: endsTime - startsTime, error }, null];
469
- }
470
- });
471
- },
472
- $types: undefined
473
- };
474
- return stargate;
50
+ const $fetch = stargateOptions.fetch ?? fetch;
51
+ const $abort = stargateOptions.abort ?? AbortController;
52
+ /**
53
+ * Restored wire failures are cast to the generated failure union: the server contract guarantees the
54
+ * fail-code string is one of the generated codes, only the runtime value is unknown statically.
55
+ */
56
+ const reviveFailure = (wire) => reviveFailureWire(wire);
57
+ /** only `fail` failures have a public business code; fault can never be matched by code */
58
+ const handleError = async (failure, code, handler) => {
59
+ if (failure === null || failure === void 0) return false;
60
+ if (failure.kind !== "fail") return false;
61
+ if (failure.code !== code) return false;
62
+ return await handler(failure.data) === true;
63
+ };
64
+ const __initEventManager = () => {
65
+ const handlers = /* @__PURE__ */ new Map();
66
+ const indexed = /* @__PURE__ */ new Map();
67
+ return {
68
+ on: (key, handler) => {
69
+ handlers.set(handler, key);
70
+ if (indexed.has(key) === false) indexed.set(key, /* @__PURE__ */ new Set());
71
+ const set = indexed.get(key);
72
+ set.add(handler);
73
+ handlers.set(handler, key);
74
+ return () => {
75
+ handlers.delete(handler);
76
+ set.delete(handler);
77
+ };
78
+ },
79
+ off: (key, handler) => {
80
+ const set = indexed.get(key);
81
+ if (!set) return;
82
+ handlers.delete(handler);
83
+ set.delete(handler);
84
+ },
85
+ emit: async (key, value) => {
86
+ const h = indexed.get(key);
87
+ if (h) for (const handler of h) await handler(value);
88
+ }
89
+ };
90
+ };
91
+ const eventManager = __initEventManager();
92
+ const bootstrap = async () => {
93
+ let baseUrl = stargateOptions.baseUrl;
94
+ if (typeof baseUrl === "function") baseUrl = await baseUrl();
95
+ if (baseUrl.endsWith("/")) baseUrl = baseUrl.slice(0, -1);
96
+ return baseUrl;
97
+ };
98
+ const baseUrlPromise = bootstrap();
99
+ let resolvedBaseUrl = null;
100
+ let cachedUrlPath = null;
101
+ let cachedUrl = null;
102
+ return {
103
+ ...eventManager,
104
+ options: stargateOptions,
105
+ async execute(path, options) {
106
+ if (options.headers === void 0) options.headers = {};
107
+ let url;
108
+ if (options.baseUrl) {
109
+ let baseUrl = options.baseUrl;
110
+ if (typeof baseUrl === "function") baseUrl = await baseUrl();
111
+ if (baseUrl.endsWith("/")) baseUrl = baseUrl.slice(0, -1);
112
+ url = baseUrl + path;
113
+ } else {
114
+ if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;
115
+ if (path === cachedUrlPath && cachedUrl !== null) url = cachedUrl;
116
+ else {
117
+ url = resolvedBaseUrl + path;
118
+ cachedUrlPath = path;
119
+ cachedUrl = url;
120
+ }
121
+ }
122
+ if (!path.endsWith("~")) {
123
+ const h = options.headers;
124
+ if (h.Accept === void 0) h.Accept = "application/json";
125
+ if (h["Content-Type"] === void 0) h["Content-Type"] = "application/json";
126
+ const cacheStrategy = options.cacheStrategy ?? "off";
127
+ let retryCount = 0;
128
+ if (options.retryStrategy === true || options.retryStrategy === 2) retryCount = 2;
129
+ else if (typeof options.retryStrategy === "number" && options.retryStrategy > 0) retryCount = options.retryStrategy;
130
+ if (cacheStrategy === "off" && retryCount === 0) try {
131
+ await eventManager.emit("milkio:executeBefore", {
132
+ path,
133
+ options
134
+ });
135
+ const body = JSON.stringify(options.params) ?? "";
136
+ await eventManager.emit("milkio:fetchBefore", {
137
+ path,
138
+ options,
139
+ body
140
+ });
141
+ const text = await (await $fetch(url, {
142
+ method: "POST",
143
+ body,
144
+ headers: options.headers
145
+ })).text();
146
+ const parsed = reviveJSONParse(JSON.parse(text));
147
+ if (parsed.success !== true) {
148
+ const failure = reviveFailure(parsed.error);
149
+ await eventManager.emit("milkio:executeError", {
150
+ handleError,
151
+ path,
152
+ options,
153
+ failure
154
+ });
155
+ return [
156
+ failure,
157
+ null,
158
+ { executeId: parsed.executeId ?? "" }
159
+ ];
160
+ }
161
+ return [
162
+ null,
163
+ parsed.data,
164
+ { executeId: parsed.executeId }
165
+ ];
166
+ } catch {
167
+ const failure = createNetworkFailure();
168
+ await eventManager.emit("milkio:executeError", {
169
+ handleError,
170
+ path,
171
+ options,
172
+ failure
173
+ });
174
+ return [
175
+ failure,
176
+ null,
177
+ { executeId: "unknown" }
178
+ ];
179
+ }
180
+ const cacheThrottleMs = options.cacheThrottleMs ?? 0;
181
+ const cacheKey = generateCacheKey(path, options.params);
182
+ let cacheStorage = stargateOptions.cacheStorage;
183
+ if (cacheStrategy !== "off" && !cacheStorage) cacheStorage = await createDefaultCacheStorage({ encryption: stargateOptions.cacheEncryption });
184
+ if (cacheStrategy !== "off" && cacheStorage && options.onCacheHit) {
185
+ const cached = await cacheStorage.get(cacheKey);
186
+ if (cached) try {
187
+ await options.onCacheHit(cached.data);
188
+ } catch {}
189
+ }
190
+ if (cacheStrategy === "throttle" && cacheStorage) {
191
+ const cached = await cacheStorage.get(cacheKey);
192
+ if (cached && Date.now() - cached.timestamp < cacheThrottleMs) return [
193
+ null,
194
+ cached.data,
195
+ { executeId: "cached" }
196
+ ];
197
+ }
198
+ await eventManager.emit("milkio:executeBefore", {
199
+ path,
200
+ options
201
+ });
202
+ const body = JSON.stringify(options.params) ?? "";
203
+ await eventManager.emit("milkio:fetchBefore", {
204
+ path,
205
+ options,
206
+ body
207
+ });
208
+ const executeRequest = async () => {
209
+ try {
210
+ const text = await (await $fetch(url, {
211
+ method: "POST",
212
+ body,
213
+ headers: options.headers
214
+ })).text();
215
+ const parsed = reviveJSONParse(JSON.parse(text));
216
+ if (parsed.success !== true) return {
217
+ failure: reviveFailure(parsed.error),
218
+ data: void 0,
219
+ executeId: parsed.executeId ?? ""
220
+ };
221
+ return {
222
+ failure: null,
223
+ data: parsed.data,
224
+ executeId: parsed.executeId
225
+ };
226
+ } catch {
227
+ return {
228
+ failure: createNetworkFailure(),
229
+ data: void 0,
230
+ executeId: "unknown"
231
+ };
232
+ }
233
+ };
234
+ let { failure, data, executeId } = await executeRequest();
235
+ for (let retryIndex = 0; retryIndex < retryCount && failure !== null && isTransportFailure(failure); retryIndex++) {
236
+ if (retryIndex > 0) await new Promise((resolve) => setTimeout(resolve, 500));
237
+ ({failure, data, executeId} = await executeRequest());
238
+ }
239
+ if (failure) {
240
+ if (cacheStrategy !== "off" && cacheStorage && failure.kind !== "fail") {
241
+ const cached = await cacheStorage.get(cacheKey);
242
+ if (cached) return [
243
+ null,
244
+ cached.data,
245
+ { executeId: "cached" }
246
+ ];
247
+ }
248
+ await eventManager.emit("milkio:executeError", {
249
+ handleError,
250
+ path,
251
+ options,
252
+ failure
253
+ });
254
+ return [
255
+ failure,
256
+ null,
257
+ { executeId }
258
+ ];
259
+ }
260
+ if (cacheStrategy !== "off" && cacheStorage) await cacheStorage.set(cacheKey, data);
261
+ return [
262
+ null,
263
+ data,
264
+ { executeId }
265
+ ];
266
+ } else {
267
+ options.cacheStrategy = "off";
268
+ options.onCacheHit = void 0;
269
+ options.cacheThrottleMs = void 0;
270
+ if (options.headers.Accept === void 0) options.headers.Accept = "text/event-stream";
271
+ if (options.headers["Content-Type"] === void 0) options.headers["Content-Type"] = "application/json";
272
+ const stacks = /* @__PURE__ */ new Map();
273
+ let stacksIndex = 0;
274
+ let iteratorIndex = 0;
275
+ let streamResult;
276
+ const streamResultFetched = withResolvers();
277
+ const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6e3;
278
+ const timer = setTimeout(() => {
279
+ failStream(createTimeoutFailure(timeout), "unknown");
280
+ }, timeout);
281
+ /** SSE error frames are `data:[wireFailure, null]`, success frames are `data:[null, value]` */
282
+ const reviveStreamFrame = (frame) => {
283
+ if (Array.isArray(frame) && frame.length === 2 && frame[0] !== null && frame[0] !== void 0) return [reviveFailure(frame[0]), null];
284
+ return frame;
285
+ };
286
+ let curRequestController;
287
+ const failStream = async (failure, executeId) => {
288
+ clearTimeout(timer);
289
+ if (!curRequestController.signal.aborted) curRequestController.abort();
290
+ await eventManager.emit("milkio:executeError", {
291
+ handleError,
292
+ path,
293
+ options,
294
+ failure
295
+ });
296
+ await iterator.throw();
297
+ streamResultFetched.reject([
298
+ failure,
299
+ null,
300
+ { executeId }
301
+ ]);
302
+ };
303
+ const onmessage = (event) => {
304
+ if (event.data.startsWith("@")) {
305
+ clearTimeout(timer);
306
+ try {
307
+ const parsed = reviveJSONParse(JSON.parse(event.data.slice(1)));
308
+ if (parsed.success !== true) {
309
+ failStream(reviveFailure(parsed.error), typeof parsed.executeId === "string" ? parsed.executeId : "");
310
+ return;
311
+ }
312
+ streamResult = parsed;
313
+ streamResultFetched.resolve(void 0);
314
+ } catch {
315
+ failStream(createNetworkFailure(), "unknown");
316
+ }
317
+ } else {
318
+ const index = ++stacksIndex;
319
+ if (stacks.has(index)) {
320
+ const stack = stacks.get(index);
321
+ stack.done = true;
322
+ stack.resolve({
323
+ done: false,
324
+ value: reviveStreamFrame(reviveJSONParse(JSON.parse(event.data)))
325
+ });
326
+ } else {
327
+ const stack = withResolvers();
328
+ stack.resolve({
329
+ done: false,
330
+ value: reviveStreamFrame(reviveJSONParse(JSON.parse(event.data)))
331
+ });
332
+ stacks.set(index, {
333
+ ...stack,
334
+ done: false
335
+ });
336
+ }
337
+ }
338
+ };
339
+ async function create() {
340
+ curRequestController = new $abort();
341
+ curRequestController.signal.addEventListener("abort", () => {
342
+ iterator.return();
343
+ });
344
+ try {
345
+ await eventManager.emit("milkio:executeBefore", {
346
+ path,
347
+ options
348
+ });
349
+ const body = JSON.stringify(options.params) ?? "";
350
+ await eventManager.emit("milkio:fetchBefore", {
351
+ path,
352
+ options,
353
+ body
354
+ });
355
+ const response = await $fetch(url, {
356
+ method: "POST",
357
+ headers: options.headers,
358
+ body,
359
+ signal: curRequestController.signal
360
+ });
361
+ if (!response.headers.get("Content-Type")?.startsWith("text/event-stream")) {
362
+ let envelope = null;
363
+ try {
364
+ envelope = reviveJSONParse(JSON.parse(await response.text()));
365
+ } catch {
366
+ envelope = null;
367
+ }
368
+ if (envelope !== null && typeof envelope === "object" && envelope.success === false) {
369
+ await failStream(reviveFailure(envelope.error), typeof envelope.executeId === "string" ? envelope.executeId : "");
370
+ return;
371
+ }
372
+ await failStream(createNetworkFailure(), "unknown");
373
+ return;
374
+ }
375
+ await getBytes(response.body, getLines(getMessages(onmessage)));
376
+ await iterator.return();
377
+ } catch {
378
+ if (curRequestController.signal.aborted) return;
379
+ await failStream(createNetworkFailure(), "unknown");
380
+ }
381
+ }
382
+ create();
383
+ const iterator = {
384
+ next() {
385
+ const index = ++iteratorIndex;
386
+ if (stacks.has(index - 2)) stacks.delete(index - 2);
387
+ if (!stacks.has(index) && !curRequestController.signal.aborted) {
388
+ const stack = withResolvers();
389
+ stacks.set(index, {
390
+ ...stack,
391
+ done: false
392
+ });
393
+ return stack.promise;
394
+ }
395
+ if (!stacks.has(index) && curRequestController.signal.aborted) {
396
+ const stack = withResolvers();
397
+ stack.resolve({
398
+ done: true,
399
+ value: void 0
400
+ });
401
+ return stack.promise;
402
+ }
403
+ return stacks.get(index).promise;
404
+ },
405
+ async return() {
406
+ if (!curRequestController.signal.aborted) curRequestController.abort();
407
+ for (const [_, iterator] of stacks) iterator.resolve({
408
+ done: true,
409
+ value: void 0
410
+ });
411
+ return {
412
+ done: true,
413
+ value: void 0
414
+ };
415
+ },
416
+ async throw() {
417
+ if (!curRequestController.signal.aborted) curRequestController.abort();
418
+ for (const [_index, stack] of stacks) {
419
+ if (stack.done) continue;
420
+ stack.done = true;
421
+ stack.resolve({
422
+ done: true,
423
+ value: void 0
424
+ });
425
+ }
426
+ return {
427
+ done: true,
428
+ value: void 0
429
+ };
430
+ },
431
+ [Symbol.asyncIterator]() {
432
+ return this;
433
+ }
434
+ };
435
+ try {
436
+ await streamResultFetched.promise;
437
+ return [
438
+ null,
439
+ iterator,
440
+ { executeId: streamResult.executeId ?? "" }
441
+ ];
442
+ } catch (error) {
443
+ return error;
444
+ }
445
+ }
446
+ },
447
+ __cookbook: { subscribe: async (baseUrl) => {
448
+ const headers = {
449
+ "Content-Type": "application/json",
450
+ Accept: "text/event-stream"
451
+ };
452
+ const body = JSON.stringify({}) ?? "";
453
+ const stacks = /* @__PURE__ */ new Map();
454
+ let stacksIndex = 0;
455
+ let iteratorIndex = 0;
456
+ const onmessage = (event) => {
457
+ const index = ++stacksIndex;
458
+ if (stacks.has(index)) stacks.get(index).resolve({
459
+ done: false,
460
+ value: reviveJSONParse(JSON.parse(event.data))
461
+ });
462
+ else {
463
+ const stack = withResolvers();
464
+ stack.resolve({
465
+ done: false,
466
+ value: reviveJSONParse(JSON.parse(event.data))
467
+ });
468
+ stacks.set(index, {
469
+ ...stack,
470
+ done: false
471
+ });
472
+ }
473
+ };
474
+ let curRequestController;
475
+ async function create() {
476
+ curRequestController = new $abort();
477
+ curRequestController.signal.addEventListener("abort", () => {
478
+ iterator.return();
479
+ });
480
+ try {
481
+ const response = await $fetch(`${baseUrl}/$subscribe`, {
482
+ method: "POST",
483
+ headers,
484
+ body,
485
+ signal: curRequestController.signal
486
+ });
487
+ const contentType = response.headers.get("Content-Type");
488
+ if (!contentType?.startsWith("text/event-stream")) throw new Error(`Expected content-type to be text/event-stream, Actual: ${contentType}`);
489
+ await getBytes(response.body, getLines(getMessages(onmessage)));
490
+ await iterator.return();
491
+ } catch (err) {
492
+ if (!curRequestController.signal.aborted) curRequestController.abort();
493
+ await iterator.throw(err);
494
+ }
495
+ }
496
+ create();
497
+ const iterator = {
498
+ next() {
499
+ const index = ++iteratorIndex;
500
+ if (stacks.has(index - 2)) stacks.delete(index - 2);
501
+ if (!stacks.has(index) && !curRequestController.signal.aborted) {
502
+ const stack = withResolvers();
503
+ stacks.set(index, {
504
+ ...stack,
505
+ done: false
506
+ });
507
+ return stack.promise;
508
+ }
509
+ if (!stacks.has(index) && curRequestController.signal.aborted) {
510
+ const stack = withResolvers();
511
+ stack.resolve({
512
+ done: true,
513
+ value: void 0
514
+ });
515
+ return stack.promise;
516
+ }
517
+ return stacks.get(index).promise;
518
+ },
519
+ async return() {
520
+ if (!curRequestController.signal.aborted) curRequestController.abort();
521
+ for (const [_, iterator] of stacks) iterator.resolve({
522
+ done: true,
523
+ value: void 0
524
+ });
525
+ return {
526
+ done: true,
527
+ value: void 0
528
+ };
529
+ },
530
+ async throw(_err) {
531
+ if (!curRequestController.signal.aborted) curRequestController.abort();
532
+ for (const [_, iterator] of stacks) iterator.resolve({
533
+ done: true,
534
+ value: void 0
535
+ });
536
+ return {
537
+ done: true,
538
+ value: void 0
539
+ };
540
+ },
541
+ [Symbol.asyncIterator]() {
542
+ return this;
543
+ }
544
+ };
545
+ try {
546
+ return iterator;
547
+ } catch (error) {
548
+ return error;
549
+ }
550
+ } },
551
+ __astraEmitEvent: async (key, options) => {
552
+ const opts = options ?? {};
553
+ if (opts.headers === void 0) opts.headers = {};
554
+ if (opts.headers["Content-Type"] === void 0) opts.headers["Content-Type"] = "application/json";
555
+ let url;
556
+ if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;
557
+ let base64Name;
558
+ if (typeof btoa !== "undefined") base64Name = btoa(key);
559
+ else if (typeof Buffer !== "undefined") base64Name = Buffer.from(key).toString("base64");
560
+ else throw new Error("No base64 encoder available");
561
+ url = `${resolvedBaseUrl}/$event/${encodeURIComponent(base64Name)}`;
562
+ try {
563
+ const body = JSON.stringify(opts.params) ?? "";
564
+ const text = await (await $fetch(url, {
565
+ method: "POST",
566
+ body,
567
+ headers: opts.headers
568
+ })).text();
569
+ const parsed = reviveJSONParse(JSON.parse(text));
570
+ if (parsed.success !== true) return [
571
+ reviveFailure(parsed.error),
572
+ null,
573
+ { executeId: parsed.executeId ?? "" }
574
+ ];
575
+ return [
576
+ null,
577
+ parsed.data,
578
+ { executeId: parsed.executeId }
579
+ ];
580
+ } catch {
581
+ return [
582
+ createNetworkFailure(),
583
+ null,
584
+ { executeId: "unknown" }
585
+ ];
586
+ }
587
+ },
588
+ async ping(options) {
589
+ return await new Promise(async (resolve) => {
590
+ const url = `${await baseUrlPromise}/generate_204`;
591
+ const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6e3;
592
+ const startsTime = Date.now();
593
+ const timer = setTimeout(() => {
594
+ resolve([{
595
+ connect: false,
596
+ delay: Date.now() - startsTime,
597
+ error: { REQUEST_TIMEOUT: {
598
+ timeout,
599
+ message: `Execute timeout after ${timeout}ms.`
600
+ } }
601
+ }, null]);
602
+ }, timeout);
603
+ try {
604
+ const response = await $fetch(url, { method: "HEAD" });
605
+ const endsTime = Date.now();
606
+ clearTimeout(timer);
607
+ if (response.status !== 204) resolve([{
608
+ connect: false,
609
+ delay: endsTime - startsTime,
610
+ error: { REQUEST_FAIL: {
611
+ response,
612
+ status: response.status,
613
+ message: "Status code not 204"
614
+ } }
615
+ }, null]);
616
+ resolve([null, {
617
+ connect: true,
618
+ delay: endsTime - startsTime,
619
+ serverTimestamp: Number(response.headers.get("Content-Type").substring(17))
620
+ }]);
621
+ } catch (error) {
622
+ return [{
623
+ connect: false,
624
+ delay: Date.now() - startsTime,
625
+ error
626
+ }, null];
627
+ }
628
+ });
629
+ },
630
+ $types: void 0
631
+ };
475
632
  }
476
- var isoDatePattern = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)(Z|[+-]\d{2}:?\d{2})?$/;
633
+ const isoDatePattern = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)(Z|[+-]\d{2}:?\d{2})?$/;
477
634
  function reviveJSONParse(json) {
478
- if (json === null || json === undefined)
479
- return json;
480
- const type = typeof json;
481
- if (type === "object") {
482
- if (json instanceof Date)
483
- return json;
484
- if (Array.isArray(json)) {
485
- const len = json.length;
486
- for (let i = 0;i < len; i++) {
487
- const result = reviveJSONParse(json[i]);
488
- if (result !== json[i])
489
- json[i] = result;
490
- }
491
- return json;
492
- }
493
- const keys = Object.keys(json);
494
- const obj = json;
495
- for (const key of keys) {
496
- const value = obj[key];
497
- const result = reviveJSONParse(value);
498
- if (result !== value)
499
- obj[key] = result;
500
- }
501
- return json;
502
- }
503
- if (type === "string") {
504
- const str = json;
505
- const len = str.length;
506
- if (len >= 20 && len <= 32 && str.charCodeAt(0) >= 48 && str.charCodeAt(0) <= 57 && str.indexOf("T") !== -1) {
507
- const match = str.match(isoDatePattern);
508
- if (match !== null) {
509
- const datePart = match[1];
510
- const tzPart = match[2];
511
- if (tzPart !== undefined) {
512
- const colonPos = tzPart.charCodeAt(3) === 58 ? (datePart?.length ?? 0) + 3 : -1;
513
- if (colonPos >= 0) {
514
- return new Date(str.substring(0, colonPos) + str.substring(colonPos + 1));
515
- }
516
- return new Date(str);
517
- }
518
- if (datePart !== undefined) {
519
- return new Date(datePart + "Z");
520
- }
521
- }
522
- }
523
- }
524
- return json;
635
+ if (json === null || json === void 0) return json;
636
+ const type = typeof json;
637
+ if (type === "object") {
638
+ if (json instanceof Date) return json;
639
+ if (Array.isArray(json)) {
640
+ const len = json.length;
641
+ for (let i = 0; i < len; i++) {
642
+ const result = reviveJSONParse(json[i]);
643
+ if (result !== json[i]) json[i] = result;
644
+ }
645
+ return json;
646
+ }
647
+ const keys = Object.keys(json);
648
+ const obj = json;
649
+ for (const key of keys) {
650
+ const value = obj[key];
651
+ const result = reviveJSONParse(value);
652
+ if (result !== value) obj[key] = result;
653
+ }
654
+ return json;
655
+ }
656
+ if (type === "string") {
657
+ const str = json;
658
+ const len = str.length;
659
+ if (len >= 20 && len <= 32 && str.charCodeAt(0) >= 48 && str.charCodeAt(0) <= 57 && str.indexOf("T") !== -1) {
660
+ const match = str.match(isoDatePattern);
661
+ if (match !== null) {
662
+ const datePart = match[1];
663
+ const tzPart = match[2];
664
+ if (tzPart !== void 0) {
665
+ const colonPos = tzPart.charCodeAt(3) === 58 ? (datePart?.length ?? 0) + 3 : -1;
666
+ if (colonPos >= 0) return new Date(str.substring(0, colonPos) + str.substring(colonPos + 1));
667
+ return new Date(str);
668
+ }
669
+ if (datePart !== void 0) return /* @__PURE__ */ new Date(datePart + "Z");
670
+ }
671
+ }
672
+ }
673
+ return json;
525
674
  }
675
+ /**
676
+ * Converts a ReadableStream into a callback pattern.
677
+ * @param stream The input ReadableStream.
678
+ * @param onChunk A function that will be called on each new byte chunk in the stream.
679
+ * @returns {Promise<void>} A promise that will be resolved when the stream closes.
680
+ */
526
681
  async function getBytes(stream, onChunk) {
527
- const reader = stream.getReader();
528
- let result;
529
- while (!(result = await reader.read()).done) {
530
- onChunk(result.value);
531
- }
682
+ const reader = stream.getReader();
683
+ let result;
684
+ while (!(result = await reader.read()).done) onChunk(result.value);
532
685
  }
686
+ /**
687
+ * Parses arbitary byte chunks into EventSource line buffers.
688
+ * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.
689
+ * @param onLine A function that will be called on each new EventSource line.
690
+ * @returns A function that should be called for each incoming byte chunk.
691
+ */
533
692
  function getLines(onLine) {
534
- let buffer;
535
- let position;
536
- let fieldLength;
537
- let discardTrailingNewline = false;
538
- return function onChunk(arr) {
539
- if (buffer === undefined) {
540
- buffer = arr;
541
- position = 0;
542
- fieldLength = -1;
543
- } else {
544
- buffer = concat(buffer, arr);
545
- }
546
- const bufLength = buffer.length;
547
- let lineStart = 0;
548
- while (position < bufLength) {
549
- if (discardTrailingNewline) {
550
- if (buffer[position] === 10) {
551
- lineStart = ++position;
552
- }
553
- discardTrailingNewline = false;
554
- }
555
- let lineEnd = -1;
556
- for (;position < bufLength && lineEnd === -1; ++position) {
557
- switch (buffer[position]) {
558
- case 58:
559
- if (fieldLength === -1) {
560
- fieldLength = position - lineStart;
561
- }
562
- break;
563
- case 13: {
564
- discardTrailingNewline = true;
565
- lineEnd = position;
566
- break;
567
- }
568
- case 10:
569
- lineEnd = position;
570
- break;
571
- }
572
- }
573
- if (lineEnd === -1) {
574
- break;
575
- }
576
- onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
577
- lineStart = position;
578
- fieldLength = -1;
579
- }
580
- if (lineStart === bufLength) {
581
- buffer = undefined;
582
- } else if (lineStart !== 0) {
583
- buffer = buffer.subarray(lineStart);
584
- position -= lineStart;
585
- }
586
- };
693
+ let buffer;
694
+ let position;
695
+ let fieldLength;
696
+ let discardTrailingNewline = false;
697
+ return function onChunk(arr) {
698
+ if (buffer === void 0) {
699
+ buffer = arr;
700
+ position = 0;
701
+ fieldLength = -1;
702
+ } else buffer = concat(buffer, arr);
703
+ const bufLength = buffer.length;
704
+ let lineStart = 0;
705
+ while (position < bufLength) {
706
+ if (discardTrailingNewline) {
707
+ if (buffer[position] === 10) lineStart = ++position;
708
+ discardTrailingNewline = false;
709
+ }
710
+ let lineEnd = -1;
711
+ for (; position < bufLength && lineEnd === -1; ++position) switch (buffer[position]) {
712
+ case 58:
713
+ if (fieldLength === -1) fieldLength = position - lineStart;
714
+ break;
715
+ case 13:
716
+ discardTrailingNewline = true;
717
+ lineEnd = position;
718
+ break;
719
+ case 10: lineEnd = position;
720
+ }
721
+ if (lineEnd === -1) break;
722
+ onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
723
+ lineStart = position;
724
+ fieldLength = -1;
725
+ }
726
+ if (lineStart === bufLength) buffer = void 0;
727
+ else if (lineStart !== 0) {
728
+ buffer = buffer.subarray(lineStart);
729
+ position -= lineStart;
730
+ }
731
+ };
587
732
  }
733
+ /**
734
+ * Parses line buffers into EventSourceMessages.
735
+ * @param onId A function that will be called on each `id` field.
736
+ * @param onRetry A function that will be called on each `retry` field.
737
+ * @param onMessage A function that will be called on each message.
738
+ * @returns A function that should be called for each incoming line buffer.
739
+ */
588
740
  function getMessages(onMessage) {
589
- let message = newMessage();
590
- const decoder = new TextDecoder;
591
- return function onLine(line, fieldLength) {
592
- if (line.length === 0) {
593
- onMessage?.(message);
594
- message = newMessage();
595
- } else if (fieldLength > 0) {
596
- const field = decoder.decode(line.subarray(0, fieldLength));
597
- const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
598
- const value = decoder.decode(line.subarray(valueOffset));
599
- switch (field) {
600
- case "data":
601
- message.data = message.data ? `${message.data}
602
- ${value}` : value;
603
- break;
604
- }
605
- }
606
- };
741
+ let message = newMessage();
742
+ const decoder = new TextDecoder();
743
+ return function onLine(line, fieldLength) {
744
+ if (line.length === 0) {
745
+ onMessage?.(message);
746
+ message = newMessage();
747
+ } else if (fieldLength > 0) {
748
+ const field = decoder.decode(line.subarray(0, fieldLength));
749
+ const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
750
+ const value = decoder.decode(line.subarray(valueOffset));
751
+ switch (field) {
752
+ case "data": message.data = message.data ? `${message.data}\n${value}` : value;
753
+ }
754
+ }
755
+ };
607
756
  }
608
757
  function concat(a, b) {
609
- const res = new Uint8Array(a.length + b.length);
610
- res.set(a);
611
- res.set(b, a.length);
612
- return res;
758
+ const res = new Uint8Array(a.length + b.length);
759
+ res.set(a);
760
+ res.set(b, a.length);
761
+ return res;
613
762
  }
614
763
  function newMessage() {
615
- return {
616
- data: ""
617
- };
764
+ return { data: "" };
618
765
  }
619
766
  function withResolvers() {
620
- let resolve;
621
- let reject;
622
- const promise = new Promise((res, rej) => {
623
- resolve = res;
624
- reject = rej;
625
- });
626
- return { promise, resolve, reject };
767
+ let resolve;
768
+ let reject;
769
+ return {
770
+ promise: new Promise((res, rej) => {
771
+ resolve = res;
772
+ reject = rej;
773
+ }),
774
+ resolve,
775
+ reject
776
+ };
627
777
  }
628
- var DB_NAME = "Stargate";
629
- var STORE_NAME = "caches";
630
- var dbInstance = null;
778
+ const DB_NAME = "Stargate";
779
+ const STORE_NAME = "caches";
780
+ let dbInstance = null;
631
781
  async function openDB() {
632
- if (dbInstance)
633
- return dbInstance;
634
- return new Promise((resolve, reject) => {
635
- const request = indexedDB.open(DB_NAME, 1);
636
- request.onerror = () => reject(request.error);
637
- request.onsuccess = () => {
638
- dbInstance = request.result;
639
- resolve(dbInstance);
640
- };
641
- request.onupgradeneeded = (event) => {
642
- const db = event.target.result;
643
- if (!db.objectStoreNames.contains(STORE_NAME)) {
644
- db.createObjectStore(STORE_NAME);
645
- }
646
- };
647
- });
782
+ if (dbInstance) return dbInstance;
783
+ return new Promise((resolve, reject) => {
784
+ const request = indexedDB.open(DB_NAME, 1);
785
+ request.onerror = () => reject(request.error);
786
+ request.onsuccess = () => {
787
+ dbInstance = request.result;
788
+ resolve(dbInstance);
789
+ };
790
+ request.onupgradeneeded = (event) => {
791
+ const db = event.target.result;
792
+ if (!db.objectStoreNames.contains(STORE_NAME)) db.createObjectStore(STORE_NAME);
793
+ };
794
+ });
648
795
  }
649
796
  async function createDefaultCacheStorage(options) {
650
- await openDB();
651
- let encryptionKey = null;
652
- const counter = new Uint8Array(16);
653
- if (options?.encryption) {
654
- const keyString = options.encryptionKey ?? DB_NAME;
655
- new TextEncoder().encode(keyString).forEach((byte, i) => {
656
- if (i < 16)
657
- counter[i] = byte;
658
- });
659
- const encoder = new TextEncoder;
660
- const keyData = encoder.encode(keyString);
661
- const importedKey = await crypto.subtle.importKey("raw", keyData, { name: "PBKDF2" }, false, ["deriveKey"]);
662
- encryptionKey = await crypto.subtle.deriveKey({
663
- name: "PBKDF2",
664
- salt: encoder.encode("milkio-stargate-cache"),
665
- iterations: 1e5,
666
- hash: "SHA-256"
667
- }, importedKey, { name: "AES-CTR", length: 256 }, false, ["encrypt", "decrypt"]);
668
- }
669
- const encryptData = async (data) => {
670
- if (!encryptionKey)
671
- return data;
672
- const jsonString = JSON.stringify(data);
673
- const encoder = new TextEncoder;
674
- const dataBytes = encoder.encode(jsonString);
675
- const encryptedArrayBuffer = await crypto.subtle.encrypt({
676
- name: "AES-CTR",
677
- counter,
678
- length: 64
679
- }, encryptionKey, dataBytes);
680
- return new Uint8Array(encryptedArrayBuffer);
681
- };
682
- const decryptData = async (encryptedData) => {
683
- if (!encryptionKey || !encryptedData)
684
- return encryptedData;
685
- const arrayBuffer = encryptedData instanceof Uint8Array ? encryptedData.buffer : encryptedData;
686
- const decryptedBytes = await crypto.subtle.decrypt({
687
- name: "AES-CTR",
688
- counter,
689
- length: 64
690
- }, encryptionKey, arrayBuffer);
691
- const decoder = new TextDecoder;
692
- const jsonString = decoder.decode(decryptedBytes);
693
- return reviveJSONParse(JSON.parse(jsonString));
694
- };
695
- return {
696
- async get(key) {
697
- const db = await openDB();
698
- return new Promise((resolve, reject) => {
699
- const transaction = db.transaction(STORE_NAME, "readonly");
700
- const store = transaction.objectStore(STORE_NAME);
701
- const request = store.get(key);
702
- request.onerror = () => reject(request.error);
703
- request.onsuccess = async () => {
704
- const result = request.result;
705
- if (!result) {
706
- resolve(null);
707
- return;
708
- }
709
- if (options?.encryption && (result.data instanceof ArrayBuffer || result.data instanceof Uint8Array)) {
710
- const decryptedData = await decryptData(result.data);
711
- resolve({ data: decryptedData, timestamp: result.timestamp });
712
- return;
713
- }
714
- resolve(result ?? null);
715
- };
716
- });
717
- },
718
- async set(key, data) {
719
- const db = await openDB();
720
- let dataToStore = data;
721
- if (options?.encryption) {
722
- dataToStore = await encryptData(data);
723
- }
724
- return new Promise((resolve, reject) => {
725
- const transaction = db.transaction(STORE_NAME, "readwrite");
726
- const store = transaction.objectStore(STORE_NAME);
727
- const request = store.put({ data: dataToStore, timestamp: Date.now() }, key);
728
- request.onerror = () => reject(request.error);
729
- request.onsuccess = () => resolve();
730
- });
731
- }
732
- };
797
+ await openDB();
798
+ let encryptionKey = null;
799
+ const counter = /* @__PURE__ */ new Uint8Array(16);
800
+ if (options?.encryption) {
801
+ const keyString = options.encryptionKey ?? DB_NAME;
802
+ new TextEncoder().encode(keyString).forEach((byte, i) => {
803
+ if (i < 16) counter[i] = byte;
804
+ });
805
+ const encoder = new TextEncoder();
806
+ const keyData = encoder.encode(keyString);
807
+ const importedKey = await crypto.subtle.importKey("raw", keyData, { name: "PBKDF2" }, false, ["deriveKey"]);
808
+ encryptionKey = await crypto.subtle.deriveKey({
809
+ name: "PBKDF2",
810
+ salt: encoder.encode("milkio-stargate-cache"),
811
+ iterations: 1e5,
812
+ hash: "SHA-256"
813
+ }, importedKey, {
814
+ name: "AES-CTR",
815
+ length: 256
816
+ }, false, ["encrypt", "decrypt"]);
817
+ }
818
+ const encryptData = async (data) => {
819
+ if (!encryptionKey) return data;
820
+ const jsonString = JSON.stringify(data);
821
+ const dataBytes = new TextEncoder().encode(jsonString);
822
+ const encryptedArrayBuffer = await crypto.subtle.encrypt({
823
+ name: "AES-CTR",
824
+ counter,
825
+ length: 64
826
+ }, encryptionKey, dataBytes);
827
+ return new Uint8Array(encryptedArrayBuffer);
828
+ };
829
+ const decryptData = async (encryptedData) => {
830
+ if (!encryptionKey || !encryptedData) return encryptedData;
831
+ const arrayBuffer = encryptedData instanceof Uint8Array ? encryptedData.buffer : encryptedData;
832
+ const decryptedBytes = await crypto.subtle.decrypt({
833
+ name: "AES-CTR",
834
+ counter,
835
+ length: 64
836
+ }, encryptionKey, arrayBuffer);
837
+ const jsonString = new TextDecoder().decode(decryptedBytes);
838
+ return reviveJSONParse(JSON.parse(jsonString));
839
+ };
840
+ return {
841
+ async get(key) {
842
+ const db = await openDB();
843
+ return new Promise((resolve, reject) => {
844
+ const request = db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(key);
845
+ request.onerror = () => reject(request.error);
846
+ request.onsuccess = async () => {
847
+ const result = request.result;
848
+ if (!result) {
849
+ resolve(null);
850
+ return;
851
+ }
852
+ if (options?.encryption && (result.data instanceof ArrayBuffer || result.data instanceof Uint8Array)) {
853
+ resolve({
854
+ data: await decryptData(result.data),
855
+ timestamp: result.timestamp
856
+ });
857
+ return;
858
+ }
859
+ resolve(result ?? null);
860
+ };
861
+ });
862
+ },
863
+ async set(key, data) {
864
+ const db = await openDB();
865
+ let dataToStore = data;
866
+ if (options?.encryption) dataToStore = await encryptData(data);
867
+ return new Promise((resolve, reject) => {
868
+ const request = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put({
869
+ data: dataToStore,
870
+ timestamp: Date.now()
871
+ }, key);
872
+ request.onerror = () => reject(request.error);
873
+ request.onsuccess = () => resolve();
874
+ });
875
+ }
876
+ };
733
877
  }
734
878
  function generateCacheKey(path, params) {
735
- return `${path}:${JSON.stringify(params ?? {})}`;
879
+ return `${path}:${JSON.stringify(params ?? {})}`;
736
880
  }
737
- export {
738
- createDefaultCacheStorage,
739
- createStargate,
740
- getBytes,
741
- getLines,
742
- getMessages,
743
- reviveJSONParse,
744
- withResolvers
745
- };
746
881
 
747
- //# debugId=BFA86016C93C122564756E2164756E21
748
- //# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../index.ts"],
  "sourcesContent": [
    "export type MilkioStargateOptions = {\n    baseUrl: string | (() => string) | (() => Promise<string>);\n    timeout?: number;\n    fetch?: typeof fetch;\n    abort?: typeof AbortController;\n    cacheStorage?: CacheStorage;\n    cacheEncryption?: boolean;\n};\n\nexport type Mixin<T, U> = U & Omit<T, keyof U>;\n\nexport type CacheStrategy = 'off' | 'fallback' | 'throttle';\n\nexport type RetryStrategy = boolean | number;\n\nexport interface CacheStorage {\n    get: (key: string) => Promise<{ data: any; timestamp: number } | null>;\n    set: (key: string, data: any) => Promise<void>;\n}\n\nexport type ExecuteOptions<T extends any> = {\n    params?: Record<any, any>;\n    headers?: Record<string, string>;\n    timeout?: number;\n    baseUrl?: string | (() => string) | (() => Promise<string>);\n    cacheStrategy?: CacheStrategy;\n    cacheThrottleMs?: number;\n    onCacheHit?: (result: T) => void | Promise<void>;\n    retryStrategy?: RetryStrategy;\n};\n\nexport type ExecuteResultsOption = { executeId: string };\n\nexport type Ping =\n    | [\n        {\n            connect: false;\n            delay: number;\n            error: any;\n        },\n        null,\n    ]\n    | [\n        null,\n        {\n            connect: true;\n            delay: number;\n            serverTimestamp: number;\n        },\n    ];\nexport async function createStargate<Generated extends { routeSchema: any; rejectCode: any; events: any }>(stargateOptions: MilkioStargateOptions) {\n    const $fetch = stargateOptions.fetch ?? fetch;\n    const $abort = stargateOptions.abort ?? AbortController;\n\n    type StargateEvents = {\n        'milkio:executeBefore': { path: string; options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }> };\n        'milkio:fetchBefore': { path: string; options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }>; body: string };\n        'milkio:executeError': {\n            path: string;\n            options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }>;\n            error: Partial<Generated['rejectCode']>;\n            handleError: <K extends keyof Partial<Generated['rejectCode']>>(error: any, key: K, handler: (error: Partial<Generated['rejectCode'][K]>) => boolean | Promise<boolean>) => Promise<void>;\n        };\n    };\n\n    const handleError: any = async (error: any, key: string, handler: (error: any) => boolean | Promise<boolean>) => {\n        if (key in error) {\n            const handled = await handler(error[key]);\n            if (handled) delete error[key];\n        }\n    };\n\n    const __initEventManager = () => {\n        const handlers = new Map<(event: any) => void, string>();\n        const indexed = new Map<string, Set<(event: any) => void>>();\n\n        const eventManager = {\n            on: <Key extends keyof StargateEvents, Handler extends (event: StargateEvents[Key]) => void>(key: Key, handler: Handler) => {\n                handlers.set(handler, key as string);\n                if (indexed.has(key as string) === false) {\n                    indexed.set(key as string, new Set());\n                }\n                const set = indexed.get(key as string)!;\n                set.add(handler);\n                handlers.set(handler, key as string);\n\n                return () => {\n                    handlers.delete(handler);\n                    set.delete(handler);\n                };\n            },\n            off: <Key extends keyof StargateEvents, Handler extends (event: StargateEvents[Key]) => void>(key: Key, handler: Handler) => {\n                const set = indexed.get(key as string);\n                if (!set) return;\n                handlers.delete(handler);\n                set.delete(handler);\n            },\n            emit: async <Key extends keyof StargateEvents, Value extends StargateEvents[Key]>(key: Key, value: Value): Promise<void> => {\n                const h = indexed.get(key as string);\n                if (h) {\n                    for (const handler of h) {\n                        await handler(value);\n                    }\n                }\n            },\n        };\n\n        return eventManager;\n    };\n\n    const eventManager = __initEventManager();\n\n    const bootstrap = async () => {\n        let baseUrl = stargateOptions.baseUrl;\n        if (typeof baseUrl === 'function') baseUrl = await baseUrl();\n        if (baseUrl.endsWith('/')) baseUrl = baseUrl.slice(0, -1);\n\n        return baseUrl;\n    };\n\n    const baseUrlPromise: Promise<string> = bootstrap();\n    // Cache resolved baseUrl to avoid await overhead on repeated calls\n    let resolvedBaseUrl: string | null = null;\n    // Cache URL for last path to avoid string concatenation per request\n    let cachedUrlPath: string | null = null;\n    let cachedUrl: string | null = null;\n\n    const stargate = {\n        ...eventManager,\n        options: stargateOptions,\n        async execute<Path extends keyof Generated['routeSchema']>(\n            path: Path,\n            options: Mixin<\n                ExecuteOptions<Generated['routeSchema'][Path]['types']['result']>,\n                {\n                    params?: Generated['routeSchema'][Path]['types']['params'];\n                }\n            >,\n        ): Promise<\n            Generated['routeSchema'][Path]['types']['🥛'] extends boolean\n            ? // action\n            [Partial<Generated['rejectCode']>, null, ExecuteResultsOption] | [null, Generated['routeSchema'][Path]['types']['result'], ExecuteResultsOption]\n            : // stream\n            // Stream schemas store the yield type directly in `result` (route-generate.ts\n            // uses `Awaited<ReturnType<handler>> extends AsyncGenerator<infer I> ? I : never`),\n            // so no `GeneratorGeneric` wrapper is needed here.\n            [Partial<Generated['rejectCode']>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated['rejectCode']>, null] | [null, Generated['routeSchema'][Path]['types']['result']], undefined>, ExecuteResultsOption]\n        > {\n            if (options.headers === undefined) options.headers = {};\n\n            let url: string;\n            if (options.baseUrl) {\n                let baseUrl = options.baseUrl;\n                if (typeof baseUrl === 'function') baseUrl = await baseUrl();\n                if (baseUrl.endsWith('/')) baseUrl = baseUrl.slice(0, -1);\n                url = baseUrl + (path as string);\n            } else {\n                if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;\n                // Cache URL for repeated path to avoid string concatenation\n                if (path === cachedUrlPath && cachedUrl !== null) {\n                    url = cachedUrl;\n                } else {\n                    url = resolvedBaseUrl + (path as string);\n                    cachedUrlPath = path as string;\n                    cachedUrl = url;\n                }\n            }\n\n            if (!(path as string).endsWith('~')) {\n                // action\n                // Set default headers only if not already present\n                const h = options.headers;\n                if (h.Accept === undefined) h.Accept = 'application/json';\n                if (h['Content-Type'] === undefined) h['Content-Type'] = 'application/json';\n\n                const cacheStrategy = options.cacheStrategy ?? 'off';\n                let retryCount = 0;\n                if (options.retryStrategy === true || options.retryStrategy === 2) {\n                    retryCount = 2;\n                } else if (typeof options.retryStrategy === 'number' && options.retryStrategy > 0) {\n                    retryCount = options.retryStrategy;\n                }\n\n                // Fast path: no cache, no retry\n                if (cacheStrategy === 'off' && retryCount === 0) {\n                    try {\n                        await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n                        const body = JSON.stringify(options.params) ?? '';\n                        await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n                        let text: string;\n                        const response = await $fetch(url, { method: 'POST', body, headers: options.headers });\n                        text = await response.text();\n                        const parsed = reviveJSONParse(JSON.parse(text));\n                        if (parsed.success !== true) {\n                            const err: any = {};\n                            err[parsed.code] = parsed.reject ?? null;\n                            return [err, null, { executeId: parsed.executeId }];\n                        }\n                        return [null, parsed.data, { executeId: parsed.executeId }];\n                    } catch (error: any) {\n                        if (error?.[0]?.REQUEST_TIMEOUT) {\n                            return [error, null, { executeId: '' }];\n                        }\n                        const errorPined = { REQUEST_FAIL: error };\n                        return [errorPined, null, { executeId: 'unknown' }];\n                    }\n                }\n\n                const cacheThrottleMs = options.cacheThrottleMs ?? 0;\n                const cacheKey = generateCacheKey(path as string, options.params);\n\n                let cacheStorage = stargateOptions.cacheStorage;\n                if (cacheStrategy !== 'off' && !cacheStorage) {\n                    cacheStorage = await createDefaultCacheStorage({ encryption: stargateOptions.cacheEncryption });\n                }\n\n                if (cacheStrategy !== 'off' && cacheStorage && options.onCacheHit) {\n                    const cached = await cacheStorage.get(cacheKey);\n                    if (cached) {\n                        try {\n                            await options.onCacheHit(cached.data);\n                        } catch {\n                            // ignore onCacheHit errors\n                        }\n                    }\n                }\n\n                if (cacheStrategy === 'throttle' && cacheStorage) {\n                    const cached = await cacheStorage.get(cacheKey);\n                    if (cached && Date.now() - cached.timestamp < cacheThrottleMs) {\n                        return [null, cached.data, { executeId: 'cached' }] as any;\n                    }\n                }\n\n                await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n                const body = JSON.stringify(options.params) ?? '';\n                await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n\n                const executeRequest = async (isRetry: boolean): Promise<{ result: { value: Record<any, any> } | null; error: any; isNetworkError: boolean }> => {\n                    try {\n                        const response = await $fetch(url, { method: 'POST', body, headers: options.headers });\n                        const text = await response.text();\n                        const parsed = JSON.parse(text);\n                        return { result: { value: parsed }, error: null, isNetworkError: false };\n                    } catch (error: any) {\n                        const isNetworkError = !error?.[0]?.REQUEST_TIMEOUT;\n                        return { result: null, error, isNetworkError };\n                    }\n                };\n\n                let { result, error, isNetworkError } = await executeRequest(false);\n\n                for (let retryIndex = 0; retryIndex < retryCount && error && isNetworkError; retryIndex++) {\n                    if (retryIndex > 0) {\n                        await new Promise((resolve) => setTimeout(resolve, 500));\n                    }\n                    const retryResult = await executeRequest(true);\n                    result = retryResult.result;\n                    error = retryResult.error;\n                    isNetworkError = retryResult.isNetworkError;\n                }\n\n                if (error) {\n                    if (error?.[0]?.REQUEST_TIMEOUT) {\n                        await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, error });\n                        return error;\n                    }\n\n                    if (cacheStrategy !== 'off' && cacheStorage && isNetworkError) {\n                        const cached = await cacheStorage.get(cacheKey);\n                        if (cached) {\n                            return [null, cached.data, { executeId: 'cached' }] as any;\n                        }\n                    }\n\n                    const errorPined = { REQUEST_FAIL: error };\n                    await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, error: errorPined });\n                    return [errorPined, null, { executeId: 'unknown' }];\n                }\n\n                if (result!.value.success !== true) {\n                    const err: any = {};\n                    err[result!.value.code] = result!.value.reject ?? null;\n                    await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, error: err });\n                    return [err, null, { executeId: result!.value.executeId }];\n                }\n\n                if (cacheStrategy !== 'off' && cacheStorage) {\n                    await cacheStorage.set(cacheKey, result!.value.data);\n                }\n\n                return [null, result!.value.data, { executeId: result!.value.executeId }] as any;\n            } else {\n                // stream\n                options.cacheStrategy = 'off';\n                options.onCacheHit = undefined;\n                options.cacheThrottleMs = undefined;\n\n                if (options.headers.Accept === undefined) options.headers.Accept = 'text/event-stream';\n                if (options.headers['Content-Type'] === undefined) options.headers['Content-Type'] = 'application/json';\n\n                const stacks: Map<\n                    number,\n                    {\n                        done: boolean;\n                        promise: Promise<IteratorResult<any>>;\n                        resolve: (value: IteratorResult<any>) => void;\n                        reject: (reason: any) => void;\n                    }\n                > = new Map();\n                let stacksIndex = 0;\n                let iteratorIndex = 0;\n                let streamResult: any;\n                const streamResultFetched = withResolvers<undefined>();\n\n                const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;\n                const timer = setTimeout(() => {\n                    streamResultFetched.reject([{ REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } }, null, { executeId: 'unknown' }]);\n                }, timeout);\n\n                const onmessage = (event: EventSourceMessage) => {\n                    if (event.data.startsWith('@')) {\n                        try {\n                            streamResult = reviveJSONParse(JSON.parse(event.data.slice(1)));\n                            streamResultFetched.resolve(undefined);\n                            clearTimeout(timer);\n                        } catch (error) {\n                            streamResultFetched.reject([{ REQUEST_FAIL: error }, null, { executeId: 'unknown' }]);\n                            clearTimeout(timer);\n                        }\n                    } else {\n                        const index = ++stacksIndex;\n                        if (stacks.has(index)) {\n                            const stack = stacks.get(index);\n                            stack!.done = true;\n                            stack!.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                        } else {\n                            const stack = withResolvers<IteratorResult<any>>();\n                            stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                            stacks.set(index, { ...stack, done: false });\n                        }\n                    }\n                };\n\n                let curRequestController: AbortController;\n\n                async function create() {\n                    curRequestController = new $abort();\n                    curRequestController.signal.addEventListener('abort', () => {\n                        iterator.return();\n                    });\n                    try {\n                        await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n\n                        const body = JSON.stringify(options!.params) ?? '';\n                        await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n\n                        const response = await $fetch(url, {\n                            method: 'POST',\n                            headers: options!.headers,\n                            body,\n                            signal: curRequestController.signal,\n                        });\n\n                        const contentType = response.headers.get('Content-Type');\n                        if (!contentType?.startsWith('text/event-stream')) {\n                            throw new Error(`Expected content-type to be ${'text/event-stream'}, Actual: ${contentType}`);\n                        }\n\n                        await getBytes(response.body!, getLines(getMessages(onmessage)));\n\n                        await iterator.return();\n                    } catch (err) {\n                        if (!curRequestController.signal.aborted) curRequestController.abort();\n                        const error = { REQUEST_FAIL: err };\n                        await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, error });\n                        await iterator.throw(err);\n                        streamResultFetched.reject([error, null, { executeId: 'unknown' }]);\n                    }\n                }\n\n                void create();\n\n                const iterator = {\n                    ...({\n                        next(): Promise<IteratorResult<unknown>> {\n                            const index = ++iteratorIndex;\n                            if (stacks.has(index - 2)) stacks.delete(index - 2);\n                            if (!stacks.has(index) && !curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stacks.set(index, { ...stack, done: false });\n                                return stack.promise;\n                            }\n                            if (!stacks.has(index) && curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stack.resolve({ done: true, value: undefined });\n                                return stack.promise;\n                            }\n                            return stacks.get(index)!.promise;\n                        },\n                        async return(): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                        async throw(err: any): Promise<IteratorResult<void>> {\n                            streamResult = {\n                                success: false,\n                                executeId: streamResult?.executeId ?? '',\n                                fail: {\n                                    code: 'NETWORK_ERROR',\n                                    message: 'Network Error',\n                                    fromClient: true,\n                                    data: err,\n                                },\n                            };\n                            for (const [_index, stack] of stacks) {\n                                if (stack.done) continue;\n                                stack.done = true;\n                                stack.resolve({ done: true, value: undefined });\n                            }\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                    } satisfies AsyncIterator<unknown>),\n                    [Symbol.asyncIterator]() {\n                        return this;\n                    },\n                };\n\n                try {\n                    await streamResultFetched.promise;\n                    return [null, iterator, { executeId: streamResult.executeId }] as any;\n                } catch (error) {\n                    return error as any;\n                }\n            }\n        },\n        __cookbook: {\n            subscribe: async (baseUrl: string) => {\n                const headers = {\n                    'Content-Type': 'application/json',\n                    Accept: 'text/event-stream',\n                };\n                const params = {};\n\n                const body = JSON.stringify(params) ?? '';\n                const stacks: Map<\n                    number,\n                    {\n                        done: boolean;\n                        promise: Promise<IteratorResult<any>>;\n                        resolve: (value: IteratorResult<any>) => void;\n                        reject: (reason: any) => void;\n                    }\n                > = new Map();\n                let stacksIndex = 0;\n                let iteratorIndex = 0;\n\n                const onmessage = (event: EventSourceMessage) => {\n                    const index = ++stacksIndex;\n                    if (stacks.has(index)) {\n                        const stack = stacks.get(index);\n                        stack!.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                    } else {\n                        const stack = withResolvers<IteratorResult<any>>();\n                        stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                        stacks.set(index, { ...stack, done: false });\n                    }\n                };\n\n                let curRequestController: AbortController;\n\n                async function create() {\n                    curRequestController = new $abort();\n                    curRequestController.signal.addEventListener('abort', () => {\n                        iterator.return();\n                    });\n                    try {\n                        const response = await $fetch(`${baseUrl}/$subscribe`, {\n                            method: 'POST',\n                            headers,\n                            body,\n                            signal: curRequestController.signal,\n                        });\n\n                        const contentType = response.headers.get('Content-Type');\n                        if (!contentType?.startsWith('text/event-stream')) {\n                            throw new Error(`Expected content-type to be ${'text/event-stream'}, Actual: ${contentType}`);\n                        }\n\n                        await getBytes(response.body!, getLines(getMessages(onmessage)));\n\n                        await iterator.return();\n                    } catch (err) {\n                        if (!curRequestController.signal.aborted) curRequestController.abort();\n                        await iterator.throw(err);\n                    }\n                }\n\n                void create();\n\n                const iterator = {\n                    ...({\n                        next(): Promise<IteratorResult<unknown>> {\n                            const index = ++iteratorIndex;\n                            if (stacks.has(index - 2)) stacks.delete(index - 2);\n                            if (!stacks.has(index) && !curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stacks.set(index, { ...stack, done: false });\n                                return stack.promise;\n                            }\n                            if (!stacks.has(index) && curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stack.resolve({ done: true, value: undefined });\n                                return stack.promise;\n                            }\n                            return stacks.get(index)!.promise;\n                        },\n                        async return(): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                        async throw(err: any): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                    } satisfies AsyncIterator<unknown>),\n                    [Symbol.asyncIterator]() {\n                        return this;\n                    },\n                };\n\n                try {\n                    return iterator;\n                } catch (error) {\n                    return error as any;\n                }\n            },\n        },\n        __astraEmitEvent: async (key: any, options?: { params?: any; headers?: Record<string, string> }) => {\n            const opts = options ?? {};\n            if (opts.headers === undefined) opts.headers = {};\n            if (opts.headers['Content-Type'] === undefined) opts.headers['Content-Type'] = 'application/json';\n\n            let url: string;\n            if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;\n            // 兼容不同运行时：优先使用 btoa，回退到 Buffer\n            let base64Name: string;\n            if (typeof btoa !== 'undefined') {\n                base64Name = btoa(key as string);\n            } else if (typeof Buffer !== 'undefined') {\n                base64Name = Buffer.from(key as string).toString('base64');\n            } else {\n                throw new Error('No base64 encoder available');\n            }\n            url = `${resolvedBaseUrl}/$event/${encodeURIComponent(base64Name)}`;\n\n            try {\n                const body = JSON.stringify(opts.params) ?? '';\n                const response = await $fetch(url, { method: 'POST', body, headers: opts.headers });\n                const text = await response.text();\n                const parsed = reviveJSONParse(JSON.parse(text));\n                if (parsed.success !== true) {\n                    const err: any = {};\n                    err[parsed.code] = parsed.reject ?? null;\n                    return [err, null, { executeId: parsed.executeId }];\n                }\n                return [null, parsed.data, { executeId: parsed.executeId }];\n            } catch (error: any) {\n                const errorPined = { REQUEST_FAIL: error };\n                return [errorPined, null, { executeId: 'unknown' }];\n            }\n        },\n\n        async ping(options?: { timeout?: number }): Promise<Ping> {\n            // oxlint-disable-next-line no-async-promise-executor\n            return await new Promise<Ping>(async (resolve) => {\n                const url = `${await baseUrlPromise}/generate_204`;\n                const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;\n                const startsTime = Date.now();\n                const timer = setTimeout(() => {\n                    const endsTime = Date.now();\n                    resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } } }, null]);\n                }, timeout);\n\n                try {\n                    const response = await $fetch(url, { method: 'HEAD' });\n                    const endsTime = Date.now();\n                    clearTimeout(timer);\n                    if (response.status !== 204) {\n                        resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_FAIL: { response, status: response.status, message: 'Status code not 204' } } }, null]);\n                    }\n\n                    resolve([null, { connect: true, delay: endsTime - startsTime, serverTimestamp: Number(response.headers.get('Content-Type')!.substring(17)) }]);\n                } catch (error: any) {\n                    const endsTime = Date.now();\n                    return [{ connect: false, delay: endsTime - startsTime, error }, null];\n                }\n            });\n        },\n        $types: undefined as unknown as {\n            generated: Generated;\n            error: Generated['rejectCode'];\n            params: {\n                [Path in keyof Generated['routeSchema']]: Generated['routeSchema'][Path]['types']['params'];\n            };\n            results: {\n                [Path in keyof Generated['routeSchema']]: Generated['routeSchema'][Path]['types']['🥛'] extends boolean\n                ? // action\n                Generated['routeSchema'][Path]['types']['result']\n                : // stream\n                // Result is already the yield type (see route-generate.ts comment).\n                AsyncGenerator<[Partial<Generated['rejectCode']>, null] | [null, Generated['routeSchema'][Path]['types']['result']], undefined>;\n            };\n        },\n    };\n\n    return stargate;\n}\n\nconst isoDatePattern = /^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?)(Z|[+-]\\d{2}:?\\d{2})?$/;\n\nexport function reviveJSONParse<T>(json: T): T {\n    if (json === null || json === undefined) return json;\n    const type = typeof json;\n    if (type === 'object') {\n        if (json instanceof Date) return json;\n        if (Array.isArray(json)) {\n            const len = json.length;\n            for (let i = 0; i < len; i++) {\n                const result = reviveJSONParse(json[i]);\n                if (result !== json[i]) json[i] = result;\n            }\n            return json;\n        }\n        const keys = Object.keys(json as object);\n        const obj = json as Record<string, unknown>;\n        for (const key of keys) {\n            const value = obj[key];\n            const result = reviveJSONParse(value);\n            if (result !== value) obj[key] = result;\n        }\n        return json;\n    }\n    if (type === 'string') {\n        const str = json as unknown as string;\n        // Quick reject: ISO date strings must start with a digit and contain 'T'\n        const len = str.length;\n        if (len >= 20 && len <= 32 && str.charCodeAt(0) >= 0x30 && str.charCodeAt(0) <= 0x39 && str.indexOf('T') !== -1) {\n            const match = str.match(isoDatePattern);\n            if (match !== null) {\n                const datePart = match[1];\n                const tzPart = match[2];\n                if (tzPart !== undefined) {\n                    const colonPos = tzPart.charCodeAt(3) === 58 ? (datePart?.length ?? 0) + 3 : -1;\n                    if (colonPos >= 0) {\n                        return new Date(str.substring(0, colonPos) + str.substring(colonPos + 1)) as any;\n                    }\n                    return new Date(str) as any;\n                }\n                if (datePart !== undefined) {\n                    return new Date(datePart + 'Z') as any;\n                }\n            }\n        }\n    }\n    return json;\n}\n\nexport interface ExecuteStreamOptions {\n    headers?: Record<string, string>;\n    timeout?: number;\n}\n\nexport interface ApiSchemaExtend {\n    apiValidator: {\n        generatedAt: number;\n        validate: Record<any, any>;\n    };\n    apiMethodsSchema: Record<any, any>;\n    apiMethodsTypeSchema: Record<any, any>;\n    apiTestsSchema: Record<any, any>;\n}\n\nexport type FailCodeExtend = Record<any, (...args: Array<any>) => any>;\n\nexport type BootstrapMiddleware = (data: { storage: ClientStorage }) => Promise<void> | void;\nexport type BeforeExecuteMiddleware = (data: { path: string; params: any; headers: Record<string, string>; storage: ClientStorage }) => Promise<void> | void;\nexport type AfterExecuteMiddleware = (data: { path: string; result: { value: any }; storage: ClientStorage }) => Promise<void> | void;\n\nexport interface MiddlewareOptions {\n    bootstrap?: BootstrapMiddleware;\n    beforeExecute?: BeforeExecuteMiddleware;\n    afterExecute?: AfterExecuteMiddleware;\n}\n\nexport interface ClientStorage {\n    getItem: (key: string) => Promise<string | null>;\n    setItem: (key: string, value: string) => Promise<void>;\n    removeItem: (key: string) => Promise<void>;\n}\n\nexport interface ExecuteResultSuccess<Result> {\n    executeId: string;\n    success: true;\n    data: Result;\n}\n\nexport type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;\n\nexport type FlattenKeys<T, Prefix extends string = ''> = {\n    [K in keyof T]: T[K] extends object ? FlattenKeys<T[K], `${Prefix}${Exclude<K, symbol>}.`> : `$input.${Prefix}${Exclude<K, symbol>}`;\n}[keyof T];\n\n// *** This part of the code is based on `@microsoft/fetch-event-source` rewrite, thanks to the work of Microsoft *** //\n// *** https://github.com/Azure/fetch-event-source/blob/main/src/parse.ts                                         *** //\n\n/**\n * Represents a message sent in an event stream\n * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format\n */\nexport interface EventSourceMessage {\n    data: string;\n}\n\n/**\n * Converts a ReadableStream into a callback pattern.\n * @param stream The input ReadableStream.\n * @param onChunk A function that will be called on each new byte chunk in the stream.\n * @returns {Promise<void>} A promise that will be resolved when the stream closes.\n */\nexport async function getBytes(stream: ReadableStream<Uint8Array>, onChunk: (arr: Uint8Array) => void) {\n    const reader = stream.getReader();\n    let result: ReadableStreamReadResult<Uint8Array>;\n    // @ts-ignore\n    while (!(result = await reader.read()).done) {\n        onChunk(result.value);\n    }\n}\n\n/**\n * Parses arbitary byte chunks into EventSource line buffers.\n * Each line should be of the format \"field: value\" and ends with \\r, \\n, or \\r\\n.\n * @param onLine A function that will be called on each new EventSource line.\n * @returns A function that should be called for each incoming byte chunk.\n */\nexport function getLines(onLine: (line: Uint8Array, fieldLength: number) => void) {\n    let buffer: Uint8Array | undefined;\n    let position: number; // current read position\n    let fieldLength: number; // length of the `field` portion of the line\n    let discardTrailingNewline = false;\n\n    // return a function that can process each incoming byte chunk:\n    return function onChunk(arr: Uint8Array) {\n        if (buffer === undefined) {\n            buffer = arr;\n            position = 0;\n            fieldLength = -1;\n        } else {\n            // we're still parsing the old line. Append the new bytes into buffer:\n            buffer = concat(buffer, arr);\n        }\n\n        const bufLength = buffer.length;\n        let lineStart = 0; // index where the current line starts\n        while (position < bufLength) {\n            if (discardTrailingNewline) {\n                if (buffer[position] === 10) {\n                    lineStart = ++position; // skip to next char\n                }\n\n                discardTrailingNewline = false;\n            }\n\n            // start looking forward till the end of line:\n            let lineEnd = -1; // index of the \\r or \\n char\n            for (; position < bufLength && lineEnd === -1; ++position) {\n                switch (buffer[position]) {\n                    case 58:\n                        if (fieldLength === -1) {\n                            // first colon in line\n                            fieldLength = position - lineStart;\n                        }\n                        break;\n                    case 13: {\n                        discardTrailingNewline = true;\n                        lineEnd = position;\n                        break;\n                    }\n                    case 10:\n                        lineEnd = position;\n                        break;\n                }\n            }\n\n            if (lineEnd === -1) {\n                // We reached the end of the buffer but the line hasn't ended.\n                // Wait for the next arr and then continue parsing:\n                break;\n            }\n\n            // we've reached the line end, send it out:\n            onLine(buffer.subarray(lineStart, lineEnd), fieldLength);\n            lineStart = position; // we're now on the next line\n            fieldLength = -1;\n        }\n\n        if (lineStart === bufLength) {\n            buffer = undefined; // we've finished reading it\n        } else if (lineStart !== 0) {\n            // Create a new view into buffer beginning at lineStart so we don't\n            // need to copy over the previous lines when we get the new arr:\n            buffer = buffer.subarray(lineStart);\n            position -= lineStart;\n        }\n    };\n}\n\n/**\n * Parses line buffers into EventSourceMessages.\n * @param onId A function that will be called on each `id` field.\n * @param onRetry A function that will be called on each `retry` field.\n * @param onMessage A function that will be called on each message.\n * @returns A function that should be called for each incoming line buffer.\n */\nexport function getMessages(onMessage?: (msg: EventSourceMessage) => void) {\n    let message = newMessage();\n    const decoder = new TextDecoder();\n\n    // return a function that can process each incoming line buffer:\n    return function onLine(line: Uint8Array, fieldLength: number) {\n        if (line.length === 0) {\n            // empty line denotes end of message. Trigger the callback and start a new message:\n            onMessage?.(message);\n            message = newMessage();\n        } else if (fieldLength > 0) {\n            // exclude comments and lines with no values\n            // line is of format \"<field>:<value>\" or \"<field>: <value>\"\n            // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation\n            const field = decoder.decode(line.subarray(0, fieldLength));\n            const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);\n            const value = decoder.decode(line.subarray(valueOffset));\n\n            switch (field) {\n                case 'data':\n                    // if this message already has data, append the new value to the old.\n                    // otherwise, just set to the new value:\n                    message.data = message.data ? `${message.data}\\n${value}` : value; // otherwise,\n                    break;\n            }\n        }\n    };\n}\n\nfunction concat(a: Uint8Array, b: Uint8Array) {\n    const res = new Uint8Array(a.length + b.length);\n    res.set(a);\n    res.set(b, a.length);\n    return res;\n}\n\nfunction newMessage(): EventSourceMessage {\n    return {\n        data: '',\n    };\n}\n\nexport function withResolvers<T = any>(): PromiseWithResolvers<T> {\n    let resolve: PromiseWithResolvers<T>['resolve'];\n    let reject: PromiseWithResolvers<T>['reject'];\n    const promise = new Promise<T>((res, rej) => {\n        resolve = res;\n        reject = rej;\n    });\n    return { promise, resolve: resolve!, reject: reject! };\n}\n\nconst DB_NAME = 'Stargate';\nconst STORE_NAME = 'caches';\nlet dbInstance: IDBDatabase | null = null;\n\nasync function openDB(): Promise<IDBDatabase> {\n    if (dbInstance) return dbInstance;\n\n    return new Promise((resolve, reject) => {\n        const request = indexedDB.open(DB_NAME, 1);\n        request.onerror = () => reject(request.error);\n        request.onsuccess = () => {\n            dbInstance = request.result;\n            resolve(dbInstance);\n        };\n        request.onupgradeneeded = (event) => {\n            const db = (event.target as IDBOpenDBRequest).result;\n            if (!db.objectStoreNames.contains(STORE_NAME)) {\n                db.createObjectStore(STORE_NAME);\n            }\n        };\n    });\n}\n\nexport async function createDefaultCacheStorage(options?: { encryption?: boolean; encryptionKey?: string }): Promise<CacheStorage> {\n    await openDB();\n\n    let encryptionKey: CryptoKey | null = null;\n    const counter = new Uint8Array(16);\n\n    if (options?.encryption) {\n        const keyString = options.encryptionKey ?? DB_NAME;\n        new TextEncoder().encode(keyString).forEach((byte, i) => {\n            if (i < 16) counter[i] = byte;\n        });\n\n        const encoder = new TextEncoder();\n        const keyData = encoder.encode(keyString);\n        const importedKey = await crypto.subtle.importKey('raw', keyData, { name: 'PBKDF2' }, false, ['deriveKey']);\n\n        encryptionKey = await crypto.subtle.deriveKey(\n            {\n                name: 'PBKDF2',\n                salt: encoder.encode('milkio-stargate-cache'),\n                iterations: 100000,\n                hash: 'SHA-256',\n            },\n            importedKey,\n            { name: 'AES-CTR', length: 256 },\n            false,\n            ['encrypt', 'decrypt'],\n        );\n    }\n\n    const encryptData = async (data: any): Promise<Uint8Array> => {\n        if (!encryptionKey) return data;\n\n        const jsonString = JSON.stringify(data);\n        const encoder = new TextEncoder();\n        const dataBytes = encoder.encode(jsonString);\n\n        const encryptedArrayBuffer = await crypto.subtle.encrypt(\n            {\n                name: 'AES-CTR',\n                counter: counter,\n                length: 64,\n            },\n            encryptionKey!,\n            dataBytes,\n        );\n\n        return new Uint8Array(encryptedArrayBuffer);\n    };\n\n    const decryptData = async (encryptedData: ArrayBuffer | Uint8Array): Promise<any> => {\n        if (!encryptionKey || !encryptedData) return encryptedData;\n\n        const arrayBuffer = encryptedData instanceof Uint8Array ? (encryptedData.buffer as ArrayBuffer) : encryptedData;\n\n        const decryptedBytes = await crypto.subtle.decrypt(\n            {\n                name: 'AES-CTR',\n                counter: counter,\n                length: 64,\n            },\n            encryptionKey!,\n            arrayBuffer,\n        );\n\n        const decoder = new TextDecoder();\n        const jsonString = decoder.decode(decryptedBytes);\n        return reviveJSONParse(JSON.parse(jsonString));\n    };\n\n    return {\n        async get(key: string): Promise<{ data: any; timestamp: number } | null> {\n            const db = await openDB();\n            return new Promise((resolve, reject) => {\n                const transaction = db.transaction(STORE_NAME, 'readonly');\n                const store = transaction.objectStore(STORE_NAME);\n                const request = store.get(key);\n                request.onerror = () => reject(request.error);\n                request.onsuccess = async () => {\n                    const result = request.result;\n                    if (!result) {\n                        resolve(null);\n                        return;\n                    }\n\n                    if (options?.encryption && (result.data instanceof ArrayBuffer || result.data instanceof Uint8Array)) {\n                        const decryptedData = await decryptData(result.data);\n                        resolve({ data: decryptedData, timestamp: result.timestamp });\n                        return;\n                    }\n\n                    resolve(result ?? null);\n                };\n            });\n        },\n        async set(key: string, data: any): Promise<void> {\n            const db = await openDB();\n            let dataToStore: any = data;\n\n            if (options?.encryption) {\n                dataToStore = await encryptData(data);\n            }\n\n            return new Promise((resolve, reject) => {\n                const transaction = db.transaction(STORE_NAME, 'readwrite');\n                const store = transaction.objectStore(STORE_NAME);\n                const request = store.put({ data: dataToStore, timestamp: Date.now() }, key);\n                request.onerror = () => reject(request.error);\n                request.onsuccess = () => resolve();\n            });\n        },\n    };\n}\n\nfunction generateCacheKey(path: string, params: any): string {\n    return `${path}:${JSON.stringify(params ?? {})}`;\n}\n"
  ],
  "mappings": "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",
  "debugId": "BFA86016C93C122564756E2164756E21",
  "names": []
}
882
+ export { createDefaultCacheStorage, createStargate, getBytes, getLines, getMessages, reviveJSONParse, withResolvers };
883
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../index.ts"],"sourcesContent":["export type MilkioStargateOptions = {\n    baseUrl: string | (() => string) | (() => Promise<string>);\n    timeout?: number;\n    fetch?: typeof fetch;\n    abort?: typeof AbortController;\n    cacheStorage?: CacheStorage;\n    cacheEncryption?: boolean;\n};\n\nexport type Mixin<T, U> = U & Omit<T, keyof U>;\n\nexport type CacheStrategy = 'off' | 'fallback' | 'throttle';\n\nexport type RetryStrategy = boolean | number;\n\nexport interface CacheStorage {\n    get: (key: string) => Promise<{ data: any; timestamp: number } | null>;\n    set: (key: string, data: any) => Promise<void>;\n}\n\nexport type ExecuteOptions<T extends any> = {\n    params?: Record<any, any>;\n    headers?: Record<string, string>;\n    timeout?: number;\n    baseUrl?: string | (() => string) | (() => Promise<string>);\n    cacheStrategy?: CacheStrategy;\n    cacheThrottleMs?: number;\n    onCacheHit?: (result: T) => void | Promise<void>;\n    retryStrategy?: RetryStrategy;\n};\n\nexport type ExecuteResultsOption = { executeId: string };\n\nexport type Ping =\n    | [\n        {\n            connect: false;\n            delay: number;\n            error: any;\n        },\n        null,\n    ]\n    | [\n        null,\n        {\n            connect: true;\n            delay: number;\n            serverTimestamp: number;\n        },\n    ];\n// ---------------------------------------------------------------------------\n// Failure protocol v2: `fail` (business rejection, code + data kept) and\n// `fault` (unexpected/internal, only the generic INTERNAL_SERVER_ERROR code).\n// The wire shapes are defined locally on purpose: stargate does not depend on milkio.\n// ---------------------------------------------------------------------------\n\nexport type MilkioFailureWire =\n    | { kind: \"fail\"; code: string; data: unknown }\n    | { kind: \"fault\"; code: \"INTERNAL_SERVER_ERROR\" };\n\n/** structural shape of a failure restored from the wire (fail keeps code/data; fault stays generic) */\nexport interface MilkioClientFailure {\n    readonly $milkioFailure: true;\n    readonly kind: \"fail\" | \"fault\";\n    readonly code: string;\n    readonly data?: unknown;\n}\n\n/** faults synthesized by the client itself; they are not server fault-codes */\nexport type MilkioClientTransportFailure =\n    | (MilkioClientFailure & { readonly kind: \"fault\"; readonly code: \"NETWORK_ERROR\" })\n    | (MilkioClientFailure & { readonly kind: \"fault\"; readonly code: \"REQUEST_TIMEOUT\"; readonly data: { timeout: number; message: string } });\n\n/**\n * Everything a stargate call can fail with: the generated client-visible failure union\n * (all fail-codes with typed data + the generic server fault) plus the client transport faults.\n * The transport members carry literal codes so `failure.code` narrowing still works for fail-codes.\n */\nexport type MilkioPublicFailure<Generated extends { failure: any } = { failure: any }> = Generated[\"failure\"] | MilkioClientTransportFailure;\n\nfunction createFail(code: string, data?: unknown): MilkioClientFailure {\n    return { $milkioFailure: true, kind: \"fail\", code, data };\n}\n\nfunction createFault(code: string, data?: unknown): MilkioClientFailure {\n    return { $milkioFailure: true, kind: \"fault\", code, data };\n}\n\nfunction createNetworkFailure(): MilkioClientTransportFailure {\n    return { $milkioFailure: true, kind: \"fault\", code: \"NETWORK_ERROR\" };\n}\n\nfunction createTimeoutFailure(timeout: number): MilkioClientTransportFailure {\n    return { $milkioFailure: true, kind: \"fault\", code: \"REQUEST_TIMEOUT\", data: { timeout, message: `Execute timeout after ${timeout}ms.` } };\n}\n\n/** only transport-level faults are retried; fail and server faults are never retried */\nfunction isTransportFailure(failure: { readonly kind: string; readonly code: string }): boolean {\n    return failure.kind === \"fault\" && (failure.code === \"NETWORK_ERROR\" || failure.code === \"REQUEST_TIMEOUT\");\n}\n\n/** restore a wire failure: fail keeps code/data, fault is always reduced to the generic code by the server */\nfunction reviveFailureWire(wire: unknown): MilkioClientFailure {\n    if (typeof wire === \"object\" && wire !== null) {\n        const parsed = wire as { kind?: unknown; code?: unknown; data?: unknown };\n        if (parsed.kind === \"fail\" && typeof parsed.code === \"string\") return createFail(parsed.code, parsed.data);\n        if (parsed.kind === \"fault\") return createFault(\"INTERNAL_SERVER_ERROR\");\n    }\n    return createFault(\"INTERNAL_SERVER_ERROR\");\n}\n\nexport async function createStargate<Generated extends { routeSchema: any; failure: MilkioClientFailure; events: any }>(stargateOptions: MilkioStargateOptions) {\n    const $fetch = stargateOptions.fetch ?? fetch;\n    const $abort = stargateOptions.abort ?? AbortController;\n\n    type PublicFailure = MilkioPublicFailure<Generated>;\n    type FailureData<Code extends string> = Extract<Generated[\"failure\"], { kind: \"fail\"; code: Code }> extends { data: infer Data } ? Data : unknown;\n    type HandleError = <Code extends string>(failure: PublicFailure, code: Code, handler: (data: FailureData<Code>) => boolean | Promise<boolean>) => Promise<boolean>;\n\n    /**\n     * Restored wire failures are cast to the generated failure union: the server contract guarantees the\n     * fail-code string is one of the generated codes, only the runtime value is unknown statically.\n     */\n    const reviveFailure = (wire: unknown): PublicFailure => reviveFailureWire(wire) as unknown as PublicFailure;\n\n    type StargateEvents = {\n        'milkio:executeBefore': { path: string; options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }> };\n        'milkio:fetchBefore': { path: string; options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }>; body: string };\n        'milkio:executeError': {\n            path: string;\n            options: Mixin<ExecuteOptions<any>, { headers: Record<string, string>; baseUrl: string }>;\n            failure: PublicFailure;\n            handleError: HandleError;\n        };\n    };\n\n    /** only `fail` failures have a public business code; fault can never be matched by code */\n    const handleError = async <Code extends string>(failure: PublicFailure, code: Code, handler: (data: FailureData<Code>) => boolean | Promise<boolean>): Promise<boolean> => {\n        if (failure === null || failure === undefined) return false;\n        if (failure.kind !== \"fail\") return false;\n        if ((failure as { readonly code: string }).code !== code) return false;\n        return (await handler((failure as { readonly data?: unknown }).data as FailureData<Code>)) === true;\n    };\n\n    const __initEventManager = () => {\n        const handlers = new Map<(event: any) => void, string>();\n        const indexed = new Map<string, Set<(event: any) => void>>();\n\n        const eventManager = {\n            on: <Key extends keyof StargateEvents, Handler extends (event: StargateEvents[Key]) => void>(key: Key, handler: Handler) => {\n                handlers.set(handler, key as string);\n                if (indexed.has(key as string) === false) {\n                    indexed.set(key as string, new Set());\n                }\n                const set = indexed.get(key as string)!;\n                set.add(handler);\n                handlers.set(handler, key as string);\n\n                return () => {\n                    handlers.delete(handler);\n                    set.delete(handler);\n                };\n            },\n            off: <Key extends keyof StargateEvents, Handler extends (event: StargateEvents[Key]) => void>(key: Key, handler: Handler) => {\n                const set = indexed.get(key as string);\n                if (!set) return;\n                handlers.delete(handler);\n                set.delete(handler);\n            },\n            emit: async <Key extends keyof StargateEvents, Value extends StargateEvents[Key]>(key: Key, value: Value): Promise<void> => {\n                const h = indexed.get(key as string);\n                if (h) {\n                    for (const handler of h) {\n                        await handler(value);\n                    }\n                }\n            },\n        };\n\n        return eventManager;\n    };\n\n    const eventManager = __initEventManager();\n\n    const bootstrap = async () => {\n        let baseUrl = stargateOptions.baseUrl;\n        if (typeof baseUrl === 'function') baseUrl = await baseUrl();\n        if (baseUrl.endsWith('/')) baseUrl = baseUrl.slice(0, -1);\n\n        return baseUrl;\n    };\n\n    const baseUrlPromise: Promise<string> = bootstrap();\n    // Cache resolved baseUrl to avoid await overhead on repeated calls\n    let resolvedBaseUrl: string | null = null;\n    // Cache URL for last path to avoid string concatenation per request\n    let cachedUrlPath: string | null = null;\n    let cachedUrl: string | null = null;\n\n    const stargate = {\n        ...eventManager,\n        options: stargateOptions,\n        async execute<Path extends keyof Generated['routeSchema']>(\n            path: Path,\n            options: Mixin<\n                ExecuteOptions<Generated['routeSchema'][Path]['types']['result']>,\n                {\n                    params?: Generated['routeSchema'][Path]['types']['params'];\n                }\n            >,\n        ): Promise<\n            Generated['routeSchema'][Path]['types']['🥛'] extends boolean\n            ? // action\n            [PublicFailure, null, ExecuteResultsOption] | [null, Generated['routeSchema'][Path]['types']['result'], ExecuteResultsOption]\n            : // stream\n            // Stream schemas store the yield type directly in `result` (route-generate.ts\n            // uses `Awaited<ReturnType<handler>> extends AsyncGenerator<infer I> ? I : never`),\n            // so no `GeneratorGeneric` wrapper is needed here.\n            [PublicFailure, null, ExecuteResultsOption] | [null, AsyncGenerator<[PublicFailure, null] | [null, Generated['routeSchema'][Path]['types']['result']], undefined>, ExecuteResultsOption]\n        > {\n            if (options.headers === undefined) options.headers = {};\n\n            let url: string;\n            if (options.baseUrl) {\n                let baseUrl = options.baseUrl;\n                if (typeof baseUrl === 'function') baseUrl = await baseUrl();\n                if (baseUrl.endsWith('/')) baseUrl = baseUrl.slice(0, -1);\n                url = baseUrl + (path as string);\n            } else {\n                if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;\n                // Cache URL for repeated path to avoid string concatenation\n                if (path === cachedUrlPath && cachedUrl !== null) {\n                    url = cachedUrl;\n                } else {\n                    url = resolvedBaseUrl + (path as string);\n                    cachedUrlPath = path as string;\n                    cachedUrl = url;\n                }\n            }\n\n            if (!(path as string).endsWith('~')) {\n                // action\n                // Set default headers only if not already present\n                const h = options.headers;\n                if (h.Accept === undefined) h.Accept = 'application/json';\n                if (h['Content-Type'] === undefined) h['Content-Type'] = 'application/json';\n\n                const cacheStrategy = options.cacheStrategy ?? 'off';\n                let retryCount = 0;\n                if (options.retryStrategy === true || options.retryStrategy === 2) {\n                    retryCount = 2;\n                } else if (typeof options.retryStrategy === 'number' && options.retryStrategy > 0) {\n                    retryCount = options.retryStrategy;\n                }\n\n                // Fast path: no cache, no retry\n                if (cacheStrategy === 'off' && retryCount === 0) {\n                    try {\n                        await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n                        const body = JSON.stringify(options.params) ?? '';\n                        await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n                        const response = await $fetch(url, { method: 'POST', body, headers: options.headers });\n                        const text = await response.text();\n                        const parsed = reviveJSONParse(JSON.parse(text));\n                        if (parsed.success !== true) {\n                            const failure = reviveFailure(parsed.error);\n                            await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, failure });\n                            return [failure, null, { executeId: parsed.executeId ?? '' }] as any;\n                        }\n                        return [null, parsed.data, { executeId: parsed.executeId }] as any;\n                    } catch {\n                        // transport-level failure (server failure is a JSON envelope with HTTP 200)\n                        const failure = createNetworkFailure();\n                        await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, failure });\n                        return [failure, null, { executeId: 'unknown' }] as any;\n                    }\n                }\n\n                const cacheThrottleMs = options.cacheThrottleMs ?? 0;\n                const cacheKey = generateCacheKey(path as string, options.params);\n\n                let cacheStorage = stargateOptions.cacheStorage;\n                if (cacheStrategy !== 'off' && !cacheStorage) {\n                    cacheStorage = await createDefaultCacheStorage({ encryption: stargateOptions.cacheEncryption });\n                }\n\n                if (cacheStrategy !== 'off' && cacheStorage && options.onCacheHit) {\n                    const cached = await cacheStorage.get(cacheKey);\n                    if (cached) {\n                        try {\n                            await options.onCacheHit(cached.data);\n                        } catch {\n                            // ignore onCacheHit errors\n                        }\n                    }\n                }\n\n                if (cacheStrategy === 'throttle' && cacheStorage) {\n                    const cached = await cacheStorage.get(cacheKey);\n                    if (cached && Date.now() - cached.timestamp < cacheThrottleMs) {\n                        return [null, cached.data, { executeId: 'cached' }] as any;\n                    }\n                }\n\n                await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n                const body = JSON.stringify(options.params) ?? '';\n                await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n\n                const executeRequest = async (): Promise<{ failure: PublicFailure | null; data: any; executeId: string }> => {\n                    try {\n                        const response = await $fetch(url, { method: 'POST', body, headers: options.headers });\n                        const text = await response.text();\n                        const parsed = reviveJSONParse(JSON.parse(text));\n                        if (parsed.success !== true) {\n                            return { failure: reviveFailure(parsed.error), data: undefined, executeId: parsed.executeId ?? '' };\n                        }\n                        return { failure: null, data: parsed.data, executeId: parsed.executeId };\n                    } catch {\n                        // transport-level failure only: HTTP status does not matter (all milkio envelopes are 200)\n                        return { failure: createNetworkFailure(), data: undefined, executeId: 'unknown' };\n                    }\n                };\n\n                let { failure, data, executeId } = await executeRequest();\n\n                // only transport-level faults are retried; fail and server faults are never retried\n                for (let retryIndex = 0; retryIndex < retryCount && failure !== null && isTransportFailure(failure); retryIndex++) {\n                    if (retryIndex > 0) {\n                        await new Promise((resolve) => setTimeout(resolve, 500));\n                    }\n                    ({ failure, data, executeId } = await executeRequest());\n                }\n\n                if (failure) {\n                    // fail is a real business result and never falls back to cache; faults may fall back\n                    if (cacheStrategy !== 'off' && cacheStorage && failure.kind !== 'fail') {\n                        const cached = await cacheStorage.get(cacheKey);\n                        if (cached) {\n                            return [null, cached.data, { executeId: 'cached' }] as any;\n                        }\n                    }\n\n                    await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, failure });\n                    return [failure, null, { executeId }] as any;\n                }\n\n                if (cacheStrategy !== 'off' && cacheStorage) {\n                    await cacheStorage.set(cacheKey, data);\n                }\n\n                return [null, data, { executeId }] as any;\n            } else {\n                // stream\n                options.cacheStrategy = 'off';\n                options.onCacheHit = undefined;\n                options.cacheThrottleMs = undefined;\n\n                if (options.headers.Accept === undefined) options.headers.Accept = 'text/event-stream';\n                if (options.headers['Content-Type'] === undefined) options.headers['Content-Type'] = 'application/json';\n\n                const stacks: Map<\n                    number,\n                    {\n                        done: boolean;\n                        promise: Promise<IteratorResult<any>>;\n                        resolve: (value: IteratorResult<any>) => void;\n                        reject: (reason: any) => void;\n                    }\n                > = new Map();\n                let stacksIndex = 0;\n                let iteratorIndex = 0;\n                let streamResult: any;\n                const streamResultFetched = withResolvers<undefined>();\n\n                const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;\n                const timer = setTimeout(() => {\n                    void failStream(createTimeoutFailure(timeout), 'unknown');\n                }, timeout);\n\n                /** SSE error frames are `data:[wireFailure, null]`, success frames are `data:[null, value]` */\n                const reviveStreamFrame = (frame: any): any => {\n                    if (Array.isArray(frame) && frame.length === 2 && frame[0] !== null && frame[0] !== undefined) {\n                        return [reviveFailure(frame[0]), null];\n                    }\n                    return frame;\n                };\n\n                let curRequestController: AbortController;\n\n                const failStream = async (failure: PublicFailure, executeId: string) => {\n                    clearTimeout(timer);\n                    if (!curRequestController.signal.aborted) curRequestController.abort();\n                    await eventManager.emit('milkio:executeError', { handleError, path: path as string, options: options as any, failure });\n                    await iterator.throw();\n                    streamResultFetched.reject([failure, null, { executeId }]);\n                };\n\n                const onmessage = (event: EventSourceMessage) => {\n                    if (event.data.startsWith('@')) {\n                        clearTimeout(timer);\n                        try {\n                            const parsed = reviveJSONParse(JSON.parse(event.data.slice(1)));\n                            if (parsed.success !== true) {\n                                // the stream rejected before producing any data (protocol v2 envelope in the first frame)\n                                void failStream(reviveFailure(parsed.error), typeof parsed.executeId === 'string' ? parsed.executeId : '');\n                                return;\n                            }\n                            streamResult = parsed;\n                            streamResultFetched.resolve(undefined);\n                        } catch {\n                            void failStream(createNetworkFailure(), 'unknown');\n                        }\n                    } else {\n                        const index = ++stacksIndex;\n                        if (stacks.has(index)) {\n                            const stack = stacks.get(index);\n                            stack!.done = true;\n                            stack!.resolve({ done: false, value: reviveStreamFrame(reviveJSONParse(JSON.parse(event.data))) });\n                        } else {\n                            const stack = withResolvers<IteratorResult<any>>();\n                            stack.resolve({ done: false, value: reviveStreamFrame(reviveJSONParse(JSON.parse(event.data))) });\n                            stacks.set(index, { ...stack, done: false });\n                        }\n                    }\n                };\n\n                async function create() {\n                    curRequestController = new $abort();\n                    curRequestController.signal.addEventListener('abort', () => {\n                        iterator.return();\n                    });\n                    try {\n                        await eventManager.emit('milkio:executeBefore', { path: path as string, options: options as any });\n\n                        const body = JSON.stringify(options!.params) ?? '';\n                        await eventManager.emit('milkio:fetchBefore', { path: path as string, options: options as any, body });\n\n                        const response = await $fetch(url, {\n                            method: 'POST',\n                            headers: options!.headers,\n                            body,\n                            signal: curRequestController.signal,\n                        });\n\n                        const contentType = response.headers.get('Content-Type');\n                        if (!contentType?.startsWith('text/event-stream')) {\n                            // the server answered with a JSON envelope instead of a stream (failure before streaming started)\n                            let envelope: any = null;\n                            try {\n                                envelope = reviveJSONParse(JSON.parse(await response.text()));\n                            } catch {\n                                envelope = null;\n                            }\n\n                            if (envelope !== null && typeof envelope === 'object' && envelope.success === false) {\n                                await failStream(reviveFailure(envelope.error), typeof envelope.executeId === 'string' ? envelope.executeId : '');\n                                return;\n                            }\n\n                            await failStream(createNetworkFailure(), 'unknown');\n                            return;\n                        }\n\n                        await getBytes(response.body!, getLines(getMessages(onmessage)));\n\n                        await iterator.return();\n                    } catch {\n                        if (curRequestController.signal.aborted) return;\n                        await failStream(createNetworkFailure(), 'unknown');\n                    }\n                }\n\n                void create();\n\n                const iterator = {\n                    ...({\n                        next(): Promise<IteratorResult<unknown>> {\n                            const index = ++iteratorIndex;\n                            if (stacks.has(index - 2)) stacks.delete(index - 2);\n                            if (!stacks.has(index) && !curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stacks.set(index, { ...stack, done: false });\n                                return stack.promise;\n                            }\n                            if (!stacks.has(index) && curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stack.resolve({ done: true, value: undefined });\n                                return stack.promise;\n                            }\n                            return stacks.get(index)!.promise;\n                        },\n                        async return(): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                        async throw(): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_index, stack] of stacks) {\n                                if (stack.done) continue;\n                                stack.done = true;\n                                stack.resolve({ done: true, value: undefined });\n                            }\n                            return { done: true, value: undefined };\n                        },\n                    } satisfies AsyncIterator<unknown>),\n                    [Symbol.asyncIterator]() {\n                        return this;\n                    },\n                };\n\n                try {\n                    await streamResultFetched.promise;\n                    return [null, iterator, { executeId: streamResult.executeId ?? '' }] as any;\n                } catch (error) {\n                    return error as any;\n                }\n            }\n        },\n        __cookbook: {\n            subscribe: async (baseUrl: string) => {\n                const headers = {\n                    'Content-Type': 'application/json',\n                    Accept: 'text/event-stream',\n                };\n                const params = {};\n\n                const body = JSON.stringify(params) ?? '';\n                const stacks: Map<\n                    number,\n                    {\n                        done: boolean;\n                        promise: Promise<IteratorResult<any>>;\n                        resolve: (value: IteratorResult<any>) => void;\n                        reject: (reason: any) => void;\n                    }\n                > = new Map();\n                let stacksIndex = 0;\n                let iteratorIndex = 0;\n\n                const onmessage = (event: EventSourceMessage) => {\n                    const index = ++stacksIndex;\n                    if (stacks.has(index)) {\n                        const stack = stacks.get(index);\n                        stack!.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                    } else {\n                        const stack = withResolvers<IteratorResult<any>>();\n                        stack.resolve({ done: false, value: reviveJSONParse(JSON.parse(event.data)) });\n                        stacks.set(index, { ...stack, done: false });\n                    }\n                };\n\n                let curRequestController: AbortController;\n\n                async function create() {\n                    curRequestController = new $abort();\n                    curRequestController.signal.addEventListener('abort', () => {\n                        iterator.return();\n                    });\n                    try {\n                        const response = await $fetch(`${baseUrl}/$subscribe`, {\n                            method: 'POST',\n                            headers,\n                            body,\n                            signal: curRequestController.signal,\n                        });\n\n                        const contentType = response.headers.get('Content-Type');\n                        if (!contentType?.startsWith('text/event-stream')) {\n                            throw new Error(`Expected content-type to be ${'text/event-stream'}, Actual: ${contentType}`);\n                        }\n\n                        await getBytes(response.body!, getLines(getMessages(onmessage)));\n\n                        await iterator.return();\n                    } catch (err) {\n                        if (!curRequestController.signal.aborted) curRequestController.abort();\n                        await iterator.throw(err);\n                    }\n                }\n\n                void create();\n\n                const iterator = {\n                    ...({\n                        next(): Promise<IteratorResult<unknown>> {\n                            const index = ++iteratorIndex;\n                            if (stacks.has(index - 2)) stacks.delete(index - 2);\n                            if (!stacks.has(index) && !curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stacks.set(index, { ...stack, done: false });\n                                return stack.promise;\n                            }\n                            if (!stacks.has(index) && curRequestController.signal.aborted) {\n                                const stack = withResolvers<IteratorResult<any>>();\n                                stack.resolve({ done: true, value: undefined });\n                                return stack.promise;\n                            }\n                            return stacks.get(index)!.promise;\n                        },\n                        async return(): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                        async throw(_err: any): Promise<IteratorResult<void>> {\n                            if (!curRequestController.signal.aborted) curRequestController.abort();\n                            for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });\n                            return { done: true, value: undefined };\n                        },\n                    } satisfies AsyncIterator<unknown>),\n                    [Symbol.asyncIterator]() {\n                        return this;\n                    },\n                };\n\n                try {\n                    return iterator;\n                } catch (error) {\n                    return error as any;\n                }\n            },\n        },\n        __astraEmitEvent: async (key: any, options?: { params?: any; headers?: Record<string, string> }) => {\n            const opts = options ?? {};\n            if (opts.headers === undefined) opts.headers = {};\n            if (opts.headers['Content-Type'] === undefined) opts.headers['Content-Type'] = 'application/json';\n\n            let url: string;\n            if (!resolvedBaseUrl) resolvedBaseUrl = await baseUrlPromise;\n            // 兼容不同运行时：优先使用 btoa，回退到 Buffer\n            let base64Name: string;\n            if (typeof btoa !== 'undefined') {\n                base64Name = btoa(key as string);\n            } else if (typeof Buffer !== 'undefined') {\n                base64Name = Buffer.from(key as string).toString('base64');\n            } else {\n                throw new Error('No base64 encoder available');\n            }\n            url = `${resolvedBaseUrl}/$event/${encodeURIComponent(base64Name)}`;\n\n            try {\n                const body = JSON.stringify(opts.params) ?? '';\n                const response = await $fetch(url, { method: 'POST', body, headers: opts.headers });\n                const text = await response.text();\n                const parsed = reviveJSONParse(JSON.parse(text));\n                if (parsed.success !== true) {\n                    return [reviveFailure(parsed.error), null, { executeId: parsed.executeId ?? '' }] as any;\n                }\n                return [null, parsed.data, { executeId: parsed.executeId }] as any;\n            } catch {\n                return [createNetworkFailure(), null, { executeId: 'unknown' }] as any;\n            }\n        },\n\n        async ping(options?: { timeout?: number }): Promise<Ping> {\n            // oxlint-disable-next-line no-async-promise-executor\n            return await new Promise<Ping>(async (resolve) => {\n                const url = `${await baseUrlPromise}/generate_204`;\n                const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;\n                const startsTime = Date.now();\n                const timer = setTimeout(() => {\n                    const endsTime = Date.now();\n                    resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } } }, null]);\n                }, timeout);\n\n                try {\n                    const response = await $fetch(url, { method: 'HEAD' });\n                    const endsTime = Date.now();\n                    clearTimeout(timer);\n                    if (response.status !== 204) {\n                        resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_FAIL: { response, status: response.status, message: 'Status code not 204' } } }, null]);\n                    }\n\n                    resolve([null, { connect: true, delay: endsTime - startsTime, serverTimestamp: Number(response.headers.get('Content-Type')!.substring(17)) }]);\n                } catch (error: any) {\n                    const endsTime = Date.now();\n                    return [{ connect: false, delay: endsTime - startsTime, error }, null];\n                }\n            });\n        },\n        $types: undefined as unknown as {\n            generated: Generated;\n            failure: PublicFailure;\n            params: {\n                [Path in keyof Generated['routeSchema']]: Generated['routeSchema'][Path]['types']['params'];\n            };\n            results: {\n                [Path in keyof Generated['routeSchema']]: Generated['routeSchema'][Path]['types']['🥛'] extends boolean\n                ? // action\n                Generated['routeSchema'][Path]['types']['result']\n                : // stream\n                // Result is already the yield type (see route-generate.ts comment).\n                AsyncGenerator<[PublicFailure, null] | [null, Generated['routeSchema'][Path]['types']['result']], undefined>;\n            };\n        },\n    };\n\n    return stargate;\n}\n\nconst isoDatePattern = /^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?)(Z|[+-]\\d{2}:?\\d{2})?$/;\n\nexport function reviveJSONParse<T>(json: T): T {\n    if (json === null || json === undefined) return json;\n    const type = typeof json;\n    if (type === 'object') {\n        if (json instanceof Date) return json;\n        if (Array.isArray(json)) {\n            const len = json.length;\n            for (let i = 0; i < len; i++) {\n                const result = reviveJSONParse(json[i]);\n                if (result !== json[i]) json[i] = result;\n            }\n            return json;\n        }\n        const keys = Object.keys(json as object);\n        const obj = json as Record<string, unknown>;\n        for (const key of keys) {\n            const value = obj[key];\n            const result = reviveJSONParse(value);\n            if (result !== value) obj[key] = result;\n        }\n        return json;\n    }\n    if (type === 'string') {\n        const str = json as unknown as string;\n        // Quick reject: ISO date strings must start with a digit and contain 'T'\n        const len = str.length;\n        if (len >= 20 && len <= 32 && str.charCodeAt(0) >= 0x30 && str.charCodeAt(0) <= 0x39 && str.indexOf('T') !== -1) {\n            const match = str.match(isoDatePattern);\n            if (match !== null) {\n                const datePart = match[1];\n                const tzPart = match[2];\n                if (tzPart !== undefined) {\n                    const colonPos = tzPart.charCodeAt(3) === 58 ? (datePart?.length ?? 0) + 3 : -1;\n                    if (colonPos >= 0) {\n                        return new Date(str.substring(0, colonPos) + str.substring(colonPos + 1)) as any;\n                    }\n                    return new Date(str) as any;\n                }\n                if (datePart !== undefined) {\n                    return new Date(datePart + 'Z') as any;\n                }\n            }\n        }\n    }\n    return json;\n}\n\nexport interface ExecuteStreamOptions {\n    headers?: Record<string, string>;\n    timeout?: number;\n}\n\nexport interface ApiSchemaExtend {\n    apiValidator: {\n        generatedAt: number;\n        validate: Record<any, any>;\n    };\n    apiMethodsSchema: Record<any, any>;\n    apiMethodsTypeSchema: Record<any, any>;\n    apiTestsSchema: Record<any, any>;\n}\n\nexport type FailCodeExtend = Record<any, (...args: Array<any>) => any>;\n\nexport type BootstrapMiddleware = (data: { storage: ClientStorage }) => Promise<void> | void;\nexport type BeforeExecuteMiddleware = (data: { path: string; params: any; headers: Record<string, string>; storage: ClientStorage }) => Promise<void> | void;\nexport type AfterExecuteMiddleware = (data: { path: string; result: { value: any }; storage: ClientStorage }) => Promise<void> | void;\n\nexport interface MiddlewareOptions {\n    bootstrap?: BootstrapMiddleware;\n    beforeExecute?: BeforeExecuteMiddleware;\n    afterExecute?: AfterExecuteMiddleware;\n}\n\nexport interface ClientStorage {\n    getItem: (key: string) => Promise<string | null>;\n    setItem: (key: string, value: string) => Promise<void>;\n    removeItem: (key: string) => Promise<void>;\n}\n\nexport interface ExecuteResultSuccess<Result> {\n    executeId: string;\n    success: true;\n    data: Result;\n}\n\nexport type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;\n\nexport type FlattenKeys<T, Prefix extends string = ''> = {\n    [K in keyof T]: T[K] extends object ? FlattenKeys<T[K], `${Prefix}${Exclude<K, symbol>}.`> : `$input.${Prefix}${Exclude<K, symbol>}`;\n}[keyof T];\n\n// *** This part of the code is based on `@microsoft/fetch-event-source` rewrite, thanks to the work of Microsoft *** //\n// *** https://github.com/Azure/fetch-event-source/blob/main/src/parse.ts                                         *** //\n\n/**\n * Represents a message sent in an event stream\n * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format\n */\nexport interface EventSourceMessage {\n    data: string;\n}\n\n/**\n * Converts a ReadableStream into a callback pattern.\n * @param stream The input ReadableStream.\n * @param onChunk A function that will be called on each new byte chunk in the stream.\n * @returns {Promise<void>} A promise that will be resolved when the stream closes.\n */\nexport async function getBytes(stream: ReadableStream<Uint8Array>, onChunk: (arr: Uint8Array) => void) {\n    const reader = stream.getReader();\n    let result: ReadableStreamReadResult<Uint8Array>;\n    // @ts-ignore\n    while (!(result = await reader.read()).done) {\n        onChunk(result.value);\n    }\n}\n\n/**\n * Parses arbitary byte chunks into EventSource line buffers.\n * Each line should be of the format \"field: value\" and ends with \\r, \\n, or \\r\\n.\n * @param onLine A function that will be called on each new EventSource line.\n * @returns A function that should be called for each incoming byte chunk.\n */\nexport function getLines(onLine: (line: Uint8Array, fieldLength: number) => void) {\n    let buffer: Uint8Array | undefined;\n    let position: number; // current read position\n    let fieldLength: number; // length of the `field` portion of the line\n    let discardTrailingNewline = false;\n\n    // return a function that can process each incoming byte chunk:\n    return function onChunk(arr: Uint8Array) {\n        if (buffer === undefined) {\n            buffer = arr;\n            position = 0;\n            fieldLength = -1;\n        } else {\n            // we're still parsing the old line. Append the new bytes into buffer:\n            buffer = concat(buffer, arr);\n        }\n\n        const bufLength = buffer.length;\n        let lineStart = 0; // index where the current line starts\n        while (position < bufLength) {\n            if (discardTrailingNewline) {\n                if (buffer[position] === 10) {\n                    lineStart = ++position; // skip to next char\n                }\n\n                discardTrailingNewline = false;\n            }\n\n            // start looking forward till the end of line:\n            let lineEnd = -1; // index of the \\r or \\n char\n            for (; position < bufLength && lineEnd === -1; ++position) {\n                switch (buffer[position]) {\n                    case 58:\n                        if (fieldLength === -1) {\n                            // first colon in line\n                            fieldLength = position - lineStart;\n                        }\n                        break;\n                    case 13: {\n                        discardTrailingNewline = true;\n                        lineEnd = position;\n                        break;\n                    }\n                    case 10:\n                        lineEnd = position;\n                        break;\n                }\n            }\n\n            if (lineEnd === -1) {\n                // We reached the end of the buffer but the line hasn't ended.\n                // Wait for the next arr and then continue parsing:\n                break;\n            }\n\n            // we've reached the line end, send it out:\n            onLine(buffer.subarray(lineStart, lineEnd), fieldLength);\n            lineStart = position; // we're now on the next line\n            fieldLength = -1;\n        }\n\n        if (lineStart === bufLength) {\n            buffer = undefined; // we've finished reading it\n        } else if (lineStart !== 0) {\n            // Create a new view into buffer beginning at lineStart so we don't\n            // need to copy over the previous lines when we get the new arr:\n            buffer = buffer.subarray(lineStart);\n            position -= lineStart;\n        }\n    };\n}\n\n/**\n * Parses line buffers into EventSourceMessages.\n * @param onId A function that will be called on each `id` field.\n * @param onRetry A function that will be called on each `retry` field.\n * @param onMessage A function that will be called on each message.\n * @returns A function that should be called for each incoming line buffer.\n */\nexport function getMessages(onMessage?: (msg: EventSourceMessage) => void) {\n    let message = newMessage();\n    const decoder = new TextDecoder();\n\n    // return a function that can process each incoming line buffer:\n    return function onLine(line: Uint8Array, fieldLength: number) {\n        if (line.length === 0) {\n            // empty line denotes end of message. Trigger the callback and start a new message:\n            onMessage?.(message);\n            message = newMessage();\n        } else if (fieldLength > 0) {\n            // exclude comments and lines with no values\n            // line is of format \"<field>:<value>\" or \"<field>: <value>\"\n            // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation\n            const field = decoder.decode(line.subarray(0, fieldLength));\n            const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);\n            const value = decoder.decode(line.subarray(valueOffset));\n\n            switch (field) {\n                case 'data':\n                    // if this message already has data, append the new value to the old.\n                    // otherwise, just set to the new value:\n                    message.data = message.data ? `${message.data}\\n${value}` : value; // otherwise,\n                    break;\n            }\n        }\n    };\n}\n\nfunction concat(a: Uint8Array, b: Uint8Array) {\n    const res = new Uint8Array(a.length + b.length);\n    res.set(a);\n    res.set(b, a.length);\n    return res;\n}\n\nfunction newMessage(): EventSourceMessage {\n    return {\n        data: '',\n    };\n}\n\n/** locally declared so the package does not require the `ESNext.Promise` lib (PromiseWithResolvers) */\nexport interface MilkioPromiseWithResolvers<T> {\n    promise: Promise<T>;\n    resolve: (value: T | PromiseLike<T>) => void;\n    reject: (reason?: any) => void;\n}\n\nexport function withResolvers<T = any>(): MilkioPromiseWithResolvers<T> {\n    let resolve: MilkioPromiseWithResolvers<T>['resolve'];\n    let reject: MilkioPromiseWithResolvers<T>['reject'];\n    const promise = new Promise<T>((res, rej) => {\n        resolve = res;\n        reject = rej;\n    });\n    return { promise, resolve: resolve!, reject: reject! };\n}\n\nconst DB_NAME = 'Stargate';\nconst STORE_NAME = 'caches';\nlet dbInstance: IDBDatabase | null = null;\n\nasync function openDB(): Promise<IDBDatabase> {\n    if (dbInstance) return dbInstance;\n\n    return new Promise((resolve, reject) => {\n        const request = indexedDB.open(DB_NAME, 1);\n        request.onerror = () => reject(request.error);\n        request.onsuccess = () => {\n            dbInstance = request.result;\n            resolve(dbInstance);\n        };\n        request.onupgradeneeded = (event) => {\n            const db = (event.target as IDBOpenDBRequest).result;\n            if (!db.objectStoreNames.contains(STORE_NAME)) {\n                db.createObjectStore(STORE_NAME);\n            }\n        };\n    });\n}\n\nexport async function createDefaultCacheStorage(options?: { encryption?: boolean; encryptionKey?: string }): Promise<CacheStorage> {\n    await openDB();\n\n    let encryptionKey: CryptoKey | null = null;\n    const counter = new Uint8Array(16);\n\n    if (options?.encryption) {\n        const keyString = options.encryptionKey ?? DB_NAME;\n        new TextEncoder().encode(keyString).forEach((byte, i) => {\n            if (i < 16) counter[i] = byte;\n        });\n\n        const encoder = new TextEncoder();\n        const keyData = encoder.encode(keyString);\n        const importedKey = await crypto.subtle.importKey('raw', keyData, { name: 'PBKDF2' }, false, ['deriveKey']);\n\n        encryptionKey = await crypto.subtle.deriveKey(\n            {\n                name: 'PBKDF2',\n                salt: encoder.encode('milkio-stargate-cache'),\n                iterations: 100000,\n                hash: 'SHA-256',\n            },\n            importedKey,\n            { name: 'AES-CTR', length: 256 },\n            false,\n            ['encrypt', 'decrypt'],\n        );\n    }\n\n    const encryptData = async (data: any): Promise<Uint8Array> => {\n        if (!encryptionKey) return data;\n\n        const jsonString = JSON.stringify(data);\n        const encoder = new TextEncoder();\n        const dataBytes = encoder.encode(jsonString);\n\n        const encryptedArrayBuffer = await crypto.subtle.encrypt(\n            {\n                name: 'AES-CTR',\n                counter: counter,\n                length: 64,\n            },\n            encryptionKey!,\n            dataBytes,\n        );\n\n        return new Uint8Array(encryptedArrayBuffer);\n    };\n\n    const decryptData = async (encryptedData: ArrayBuffer | Uint8Array): Promise<any> => {\n        if (!encryptionKey || !encryptedData) return encryptedData;\n\n        const arrayBuffer = encryptedData instanceof Uint8Array ? (encryptedData.buffer as ArrayBuffer) : encryptedData;\n\n        const decryptedBytes = await crypto.subtle.decrypt(\n            {\n                name: 'AES-CTR',\n                counter: counter,\n                length: 64,\n            },\n            encryptionKey!,\n            arrayBuffer,\n        );\n\n        const decoder = new TextDecoder();\n        const jsonString = decoder.decode(decryptedBytes);\n        return reviveJSONParse(JSON.parse(jsonString));\n    };\n\n    return {\n        async get(key: string): Promise<{ data: any; timestamp: number } | null> {\n            const db = await openDB();\n            return new Promise((resolve, reject) => {\n                const transaction = db.transaction(STORE_NAME, 'readonly');\n                const store = transaction.objectStore(STORE_NAME);\n                const request = store.get(key);\n                request.onerror = () => reject(request.error);\n                request.onsuccess = async () => {\n                    const result = request.result;\n                    if (!result) {\n                        resolve(null);\n                        return;\n                    }\n\n                    if (options?.encryption && (result.data instanceof ArrayBuffer || result.data instanceof Uint8Array)) {\n                        const decryptedData = await decryptData(result.data);\n                        resolve({ data: decryptedData, timestamp: result.timestamp });\n                        return;\n                    }\n\n                    resolve(result ?? null);\n                };\n            });\n        },\n        async set(key: string, data: any): Promise<void> {\n            const db = await openDB();\n            let dataToStore: any = data;\n\n            if (options?.encryption) {\n                dataToStore = await encryptData(data);\n            }\n\n            return new Promise((resolve, reject) => {\n                const transaction = db.transaction(STORE_NAME, 'readwrite');\n                const store = transaction.objectStore(STORE_NAME);\n                const request = store.put({ data: dataToStore, timestamp: Date.now() }, key);\n                request.onerror = () => reject(request.error);\n                request.onsuccess = () => resolve();\n            });\n        },\n    };\n}\n\nfunction generateCacheKey(path: string, params: any): string {\n    return `${path}:${JSON.stringify(params ?? {})}`;\n}\n"],"mappings":";AAgFA,SAAS,WAAW,MAAc,MAAqC;CACnE,OAAO;EAAE,gBAAgB;EAAM,MAAM;EAAQ;EAAM;CAAK;AAC5D;AAEA,SAAS,YAAY,MAAc,MAAqC;CACpE,OAAO;EAAE,gBAAgB;EAAM,MAAM;EAAS;EAAM;CAAK;AAC7D;AAEA,SAAS,uBAAqD;CAC1D,OAAO;EAAE,gBAAgB;EAAM,MAAM;EAAS,MAAM;CAAgB;AACxE;AAEA,SAAS,qBAAqB,SAA+C;CACzE,OAAO;EAAE,gBAAgB;EAAM,MAAM;EAAS,MAAM;EAAmB,MAAM;GAAE;GAAS,SAAS,yBAAyB,QAAQ;EAAK;CAAE;AAC7I;;AAGA,SAAS,mBAAmB,SAAoE;CAC5F,OAAO,QAAQ,SAAS,YAAY,QAAQ,SAAS,mBAAmB,QAAQ,SAAS;AAC7F;;AAGA,SAAS,kBAAkB,MAAoC;CAC3D,IAAI,OAAO,SAAS,YAAY,SAAS,MAAM;EAC3C,MAAM,SAAS;EACf,IAAI,OAAO,SAAS,UAAU,OAAO,OAAO,SAAS,UAAU,OAAO,WAAW,OAAO,MAAM,OAAO,IAAI;EACzG,IAAI,OAAO,SAAS,SAAS,OAAO,YAAY,uBAAuB;CAC3E;CACA,OAAO,YAAY,uBAAuB;AAC9C;AAEA,eAAsB,eAAkG,iBAAwC;CAC5J,MAAM,SAAS,gBAAgB,SAAS;CACxC,MAAM,SAAS,gBAAgB,SAAS;;;;;CAUxC,MAAM,iBAAiB,SAAiC,kBAAkB,IAAI;;CAc9E,MAAM,cAAc,OAA4B,SAAwB,MAAY,YAAuF;EACvK,IAAI,YAAY,QAAQ,YAAY,QAAW,OAAO;EACtD,IAAI,QAAQ,SAAS,QAAQ,OAAO;EACpC,IAAK,QAAsC,SAAS,MAAM,OAAO;EACjE,OAAQ,MAAM,QAAS,QAAwC,IAAyB,MAAO;CACnG;CAEA,MAAM,2BAA2B;EAC7B,MAAM,2BAAW,IAAI,IAAkC;EACvD,MAAM,0BAAU,IAAI,IAAuC;EAiC3D,OAAO;GA9BH,KAA6F,KAAU,YAAqB;IACxH,SAAS,IAAI,SAAS,GAAa;IACnC,IAAI,QAAQ,IAAI,GAAa,MAAM,OAC/B,QAAQ,IAAI,qBAAe,IAAI,IAAI,CAAC;IAExC,MAAM,MAAM,QAAQ,IAAI,GAAa;IACrC,IAAI,IAAI,OAAO;IACf,SAAS,IAAI,SAAS,GAAa;IAEnC,aAAa;KACT,SAAS,OAAO,OAAO;KACvB,IAAI,OAAO,OAAO;IACtB;GACJ;GACA,MAA8F,KAAU,YAAqB;IACzH,MAAM,MAAM,QAAQ,IAAI,GAAa;IACrC,IAAI,CAAC,KAAK;IACV,SAAS,OAAO,OAAO;IACvB,IAAI,OAAO,OAAO;GACtB;GACA,MAAM,OAA4E,KAAU,UAAgC;IACxH,MAAM,IAAI,QAAQ,IAAI,GAAa;IACnC,IAAI,GACA,KAAK,MAAM,WAAW,GAClB,MAAM,QAAQ,KAAK;GAG/B;EAGc;CACtB;CAEA,MAAM,eAAe,mBAAmB;CAExC,MAAM,YAAY,YAAY;EAC1B,IAAI,UAAU,gBAAgB;EAC9B,IAAI,OAAO,YAAY,YAAY,UAAU,MAAM,QAAQ;EAC3D,IAAI,QAAQ,SAAS,GAAG,GAAG,UAAU,QAAQ,MAAM,GAAG,EAAE;EAExD,OAAO;CACX;CAEA,MAAM,iBAAkC,UAAU;CAElD,IAAI,kBAAiC;CAErC,IAAI,gBAA+B;CACnC,IAAI,YAA2B;CAqf/B,OAAO;EAlfH,GAAG;EACH,SAAS;EACT,MAAM,QACF,MACA,SAeF;GACE,IAAI,QAAQ,YAAY,QAAW,QAAQ,UAAU,CAAC;GAEtD,IAAI;GACJ,IAAI,QAAQ,SAAS;IACjB,IAAI,UAAU,QAAQ;IACtB,IAAI,OAAO,YAAY,YAAY,UAAU,MAAM,QAAQ;IAC3D,IAAI,QAAQ,SAAS,GAAG,GAAG,UAAU,QAAQ,MAAM,GAAG,EAAE;IACxD,MAAM,UAAW;GACrB,OAAO;IACH,IAAI,CAAC,iBAAiB,kBAAkB,MAAM;IAE9C,IAAI,SAAS,iBAAiB,cAAc,MACxC,MAAM;SACH;KACH,MAAM,kBAAmB;KACzB,gBAAgB;KAChB,YAAY;IAChB;GACJ;GAEA,IAAI,CAAE,KAAgB,SAAS,GAAG,GAAG;IAGjC,MAAM,IAAI,QAAQ;IAClB,IAAI,EAAE,WAAW,QAAW,EAAE,SAAS;IACvC,IAAI,EAAE,oBAAoB,QAAW,EAAE,kBAAkB;IAEzD,MAAM,gBAAgB,QAAQ,iBAAiB;IAC/C,IAAI,aAAa;IACjB,IAAI,QAAQ,kBAAkB,QAAQ,QAAQ,kBAAkB,GAC5D,aAAa;SACV,IAAI,OAAO,QAAQ,kBAAkB,YAAY,QAAQ,gBAAgB,GAC5E,aAAa,QAAQ;IAIzB,IAAI,kBAAkB,SAAS,eAAe,GAC1C,IAAI;KACA,MAAM,aAAa,KAAK,wBAAwB;MAAQ;MAAyB;KAAe,CAAC;KACjG,MAAM,OAAO,KAAK,UAAU,QAAQ,MAAM,KAAK;KAC/C,MAAM,aAAa,KAAK,sBAAsB;MAAQ;MAAyB;MAAgB;KAAK,CAAC;KAErG,MAAM,OAAO,OAAM,MADI,OAAO,KAAK;MAAE,QAAQ;MAAQ;MAAM,SAAS,QAAQ;KAAQ,CAAC,EAC1D,CAAC,KAAK;KACjC,MAAM,SAAS,gBAAgB,KAAK,MAAM,IAAI,CAAC;KAC/C,IAAI,OAAO,YAAY,MAAM;MACzB,MAAM,UAAU,cAAc,OAAO,KAAK;MAC1C,MAAM,aAAa,KAAK,uBAAuB;OAAE;OAAmB;OAAyB;OAAgB;MAAQ,CAAC;MACtH,OAAO;OAAC;OAAS;OAAM,EAAE,WAAW,OAAO,aAAa,GAAG;MAAC;KAChE;KACA,OAAO;MAAC;MAAM,OAAO;MAAM,EAAE,WAAW,OAAO,UAAU;KAAC;IAC9D,QAAQ;KAEJ,MAAM,UAAU,qBAAqB;KACrC,MAAM,aAAa,KAAK,uBAAuB;MAAE;MAAmB;MAAyB;MAAgB;KAAQ,CAAC;KACtH,OAAO;MAAC;MAAS;MAAM,EAAE,WAAW,UAAU;KAAC;IACnD;IAGJ,MAAM,kBAAkB,QAAQ,mBAAmB;IACnD,MAAM,WAAW,iBAAiB,MAAgB,QAAQ,MAAM;IAEhE,IAAI,eAAe,gBAAgB;IACnC,IAAI,kBAAkB,SAAS,CAAC,cAC5B,eAAe,MAAM,0BAA0B,EAAE,YAAY,gBAAgB,gBAAgB,CAAC;IAGlG,IAAI,kBAAkB,SAAS,gBAAgB,QAAQ,YAAY;KAC/D,MAAM,SAAS,MAAM,aAAa,IAAI,QAAQ;KAC9C,IAAI,QACA,IAAI;MACA,MAAM,QAAQ,WAAW,OAAO,IAAI;KACxC,QAAQ,CAER;IAER;IAEA,IAAI,kBAAkB,cAAc,cAAc;KAC9C,MAAM,SAAS,MAAM,aAAa,IAAI,QAAQ;KAC9C,IAAI,UAAU,KAAK,IAAI,IAAI,OAAO,YAAY,iBAC1C,OAAO;MAAC;MAAM,OAAO;MAAM,EAAE,WAAW,SAAS;KAAC;IAE1D;IAEA,MAAM,aAAa,KAAK,wBAAwB;KAAQ;KAAyB;IAAe,CAAC;IACjG,MAAM,OAAO,KAAK,UAAU,QAAQ,MAAM,KAAK;IAC/C,MAAM,aAAa,KAAK,sBAAsB;KAAQ;KAAyB;KAAgB;IAAK,CAAC;IAErG,MAAM,iBAAiB,YAAsF;KACzG,IAAI;MAEA,MAAM,OAAO,OAAM,MADI,OAAO,KAAK;OAAE,QAAQ;OAAQ;OAAM,SAAS,QAAQ;MAAQ,CAAC,EAC1D,CAAC,KAAK;MACjC,MAAM,SAAS,gBAAgB,KAAK,MAAM,IAAI,CAAC;MAC/C,IAAI,OAAO,YAAY,MACnB,OAAO;OAAE,SAAS,cAAc,OAAO,KAAK;OAAG,MAAM;OAAW,WAAW,OAAO,aAAa;MAAG;MAEtG,OAAO;OAAE,SAAS;OAAM,MAAM,OAAO;OAAM,WAAW,OAAO;MAAU;KAC3E,QAAQ;MAEJ,OAAO;OAAE,SAAS,qBAAqB;OAAG,MAAM;OAAW,WAAW;MAAU;KACpF;IACJ;IAEA,IAAI,EAAE,SAAS,MAAM,cAAc,MAAM,eAAe;IAGxD,KAAK,IAAI,aAAa,GAAG,aAAa,cAAc,YAAY,QAAQ,mBAAmB,OAAO,GAAG,cAAc;KAC/G,IAAI,aAAa,GACb,MAAM,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;KAE3D,CAAC,CAAE,SAAS,MAAM,aAAc,MAAM,eAAe;IACzD;IAEA,IAAI,SAAS;KAET,IAAI,kBAAkB,SAAS,gBAAgB,QAAQ,SAAS,QAAQ;MACpE,MAAM,SAAS,MAAM,aAAa,IAAI,QAAQ;MAC9C,IAAI,QACA,OAAO;OAAC;OAAM,OAAO;OAAM,EAAE,WAAW,SAAS;MAAC;KAE1D;KAEA,MAAM,aAAa,KAAK,uBAAuB;MAAE;MAAmB;MAAyB;MAAgB;KAAQ,CAAC;KACtH,OAAO;MAAC;MAAS;MAAM,EAAE,UAAU;KAAC;IACxC;IAEA,IAAI,kBAAkB,SAAS,cAC3B,MAAM,aAAa,IAAI,UAAU,IAAI;IAGzC,OAAO;KAAC;KAAM;KAAM,EAAE,UAAU;IAAC;GACrC,OAAO;IAEH,QAAQ,gBAAgB;IACxB,QAAQ,aAAa;IACrB,QAAQ,kBAAkB;IAE1B,IAAI,QAAQ,QAAQ,WAAW,QAAW,QAAQ,QAAQ,SAAS;IACnE,IAAI,QAAQ,QAAQ,oBAAoB,QAAW,QAAQ,QAAQ,kBAAkB;IAErF,MAAM,yBAQF,IAAI,IAAI;IACZ,IAAI,cAAc;IAClB,IAAI,gBAAgB;IACpB,IAAI;IACJ,MAAM,sBAAsB,cAAyB;IAErD,MAAM,UAAU,iBAAiB,WAAW,SAAS,WAAW;IAChE,MAAM,QAAQ,iBAAiB;KAC3B,AAAK,WAAW,qBAAqB,OAAO,GAAG,SAAS;IAC5D,GAAG,OAAO;;IAGV,MAAM,qBAAqB,UAAoB;KAC3C,IAAI,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,KAAK,MAAM,OAAO,QAAQ,MAAM,OAAO,QAChF,OAAO,CAAC,cAAc,MAAM,EAAE,GAAG,IAAI;KAEzC,OAAO;IACX;IAEA,IAAI;IAEJ,MAAM,aAAa,OAAO,SAAwB,cAAsB;KACpE,aAAa,KAAK;KAClB,IAAI,CAAC,qBAAqB,OAAO,SAAS,qBAAqB,MAAM;KACrE,MAAM,aAAa,KAAK,uBAAuB;MAAE;MAAmB;MAAyB;MAAgB;KAAQ,CAAC;KACtH,MAAM,SAAS,MAAM;KACrB,oBAAoB,OAAO;MAAC;MAAS;MAAM,EAAE,UAAU;KAAC,CAAC;IAC7D;IAEA,MAAM,aAAa,UAA8B;KAC7C,IAAI,MAAM,KAAK,WAAW,GAAG,GAAG;MAC5B,aAAa,KAAK;MAClB,IAAI;OACA,MAAM,SAAS,gBAAgB,KAAK,MAAM,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC;OAC9D,IAAI,OAAO,YAAY,MAAM;QAEzB,AAAK,WAAW,cAAc,OAAO,KAAK,GAAG,OAAO,OAAO,cAAc,WAAW,OAAO,YAAY,EAAE;QACzG;OACJ;OACA,eAAe;OACf,oBAAoB,QAAQ,MAAS;MACzC,QAAQ;OACJ,AAAK,WAAW,qBAAqB,GAAG,SAAS;MACrD;KACJ,OAAO;MACH,MAAM,QAAQ,EAAE;MAChB,IAAI,OAAO,IAAI,KAAK,GAAG;OACnB,MAAM,QAAQ,OAAO,IAAI,KAAK;OAC9B,MAAO,OAAO;OACd,MAAO,QAAQ;QAAE,MAAM;QAAO,OAAO,kBAAkB,gBAAgB,KAAK,MAAM,MAAM,IAAI,CAAC,CAAC;OAAE,CAAC;MACrG,OAAO;OACH,MAAM,QAAQ,cAAmC;OACjD,MAAM,QAAQ;QAAE,MAAM;QAAO,OAAO,kBAAkB,gBAAgB,KAAK,MAAM,MAAM,IAAI,CAAC,CAAC;OAAE,CAAC;OAChG,OAAO,IAAI,OAAO;QAAE,GAAG;QAAO,MAAM;OAAM,CAAC;MAC/C;KACJ;IACJ;IAEA,eAAe,SAAS;KACpB,uBAAuB,IAAI,OAAO;KAClC,qBAAqB,OAAO,iBAAiB,eAAe;MACxD,SAAS,OAAO;KACpB,CAAC;KACD,IAAI;MACA,MAAM,aAAa,KAAK,wBAAwB;OAAQ;OAAyB;MAAe,CAAC;MAEjG,MAAM,OAAO,KAAK,UAAU,QAAS,MAAM,KAAK;MAChD,MAAM,aAAa,KAAK,sBAAsB;OAAQ;OAAyB;OAAgB;MAAK,CAAC;MAErG,MAAM,WAAW,MAAM,OAAO,KAAK;OAC/B,QAAQ;OACR,SAAS,QAAS;OAClB;OACA,QAAQ,qBAAqB;MACjC,CAAC;MAGD,IAAI,CADgB,SAAS,QAAQ,IAAI,cAC1B,CAAC,EAAE,WAAW,mBAAmB,GAAG;OAE/C,IAAI,WAAgB;OACpB,IAAI;QACA,WAAW,gBAAgB,KAAK,MAAM,MAAM,SAAS,KAAK,CAAC,CAAC;OAChE,QAAQ;QACJ,WAAW;OACf;OAEA,IAAI,aAAa,QAAQ,OAAO,aAAa,YAAY,SAAS,YAAY,OAAO;QACjF,MAAM,WAAW,cAAc,SAAS,KAAK,GAAG,OAAO,SAAS,cAAc,WAAW,SAAS,YAAY,EAAE;QAChH;OACJ;OAEA,MAAM,WAAW,qBAAqB,GAAG,SAAS;OAClD;MACJ;MAEA,MAAM,SAAS,SAAS,MAAO,SAAS,YAAY,SAAS,CAAC,CAAC;MAE/D,MAAM,SAAS,OAAO;KAC1B,QAAQ;MACJ,IAAI,qBAAqB,OAAO,SAAS;MACzC,MAAM,WAAW,qBAAqB,GAAG,SAAS;KACtD;IACJ;IAEA,AAAK,OAAO;IAEZ,MAAM,WAAW;KAET,OAAyC;MACrC,MAAM,QAAQ,EAAE;MAChB,IAAI,OAAO,IAAI,QAAQ,CAAC,GAAG,OAAO,OAAO,QAAQ,CAAC;MAClD,IAAI,CAAC,OAAO,IAAI,KAAK,KAAK,CAAC,qBAAqB,OAAO,SAAS;OAC5D,MAAM,QAAQ,cAAmC;OACjD,OAAO,IAAI,OAAO;QAAE,GAAG;QAAO,MAAM;OAAM,CAAC;OAC3C,OAAO,MAAM;MACjB;MACA,IAAI,CAAC,OAAO,IAAI,KAAK,KAAK,qBAAqB,OAAO,SAAS;OAC3D,MAAM,QAAQ,cAAmC;OACjD,MAAM,QAAQ;QAAE,MAAM;QAAM,OAAO;OAAU,CAAC;OAC9C,OAAO,MAAM;MACjB;MACA,OAAO,OAAO,IAAI,KAAK,CAAC,CAAE;KAC9B;KACA,MAAM,SAAwC;MAC1C,IAAI,CAAC,qBAAqB,OAAO,SAAS,qBAAqB,MAAM;MACrE,KAAK,MAAM,CAAC,GAAG,aAAa,QAAQ,SAAS,QAAQ;OAAE,MAAM;OAAM,OAAO;MAAU,CAAC;MACrF,OAAO;OAAE,MAAM;OAAM,OAAO;MAAU;KAC1C;KACA,MAAM,QAAuC;MACzC,IAAI,CAAC,qBAAqB,OAAO,SAAS,qBAAqB,MAAM;MACrE,KAAK,MAAM,CAAC,QAAQ,UAAU,QAAQ;OAClC,IAAI,MAAM,MAAM;OAChB,MAAM,OAAO;OACb,MAAM,QAAQ;QAAE,MAAM;QAAM,OAAO;OAAU,CAAC;MAClD;MACA,OAAO;OAAE,MAAM;OAAM,OAAO;MAAU;KAC1C;KAEJ,CAAC,OAAO,iBAAiB;MACrB,OAAO;KACX;IACJ;IAEA,IAAI;KACA,MAAM,oBAAoB;KAC1B,OAAO;MAAC;MAAM;MAAU,EAAE,WAAW,aAAa,aAAa,GAAG;KAAC;IACvE,SAAS,OAAO;KACZ,OAAO;IACX;GACJ;EACJ;EACA,YAAY,EACR,WAAW,OAAO,YAAoB;GAClC,MAAM,UAAU;IACZ,gBAAgB;IAChB,QAAQ;GACZ;GAGA,MAAM,OAAO,KAAK,UAAU,CAAK,CAAC,KAAK;GACvC,MAAM,yBAQF,IAAI,IAAI;GACZ,IAAI,cAAc;GAClB,IAAI,gBAAgB;GAEpB,MAAM,aAAa,UAA8B;IAC7C,MAAM,QAAQ,EAAE;IAChB,IAAI,OAAO,IAAI,KAAK,GAEhB,AADc,OAAO,IAAI,KACrB,CAAC,CAAE,QAAQ;KAAE,MAAM;KAAO,OAAO,gBAAgB,KAAK,MAAM,MAAM,IAAI,CAAC;IAAE,CAAC;SAC3E;KACH,MAAM,QAAQ,cAAmC;KACjD,MAAM,QAAQ;MAAE,MAAM;MAAO,OAAO,gBAAgB,KAAK,MAAM,MAAM,IAAI,CAAC;KAAE,CAAC;KAC7E,OAAO,IAAI,OAAO;MAAE,GAAG;MAAO,MAAM;KAAM,CAAC;IAC/C;GACJ;GAEA,IAAI;GAEJ,eAAe,SAAS;IACpB,uBAAuB,IAAI,OAAO;IAClC,qBAAqB,OAAO,iBAAiB,eAAe;KACxD,SAAS,OAAO;IACpB,CAAC;IACD,IAAI;KACA,MAAM,WAAW,MAAM,OAAO,GAAG,QAAQ,cAAc;MACnD,QAAQ;MACR;MACA;MACA,QAAQ,qBAAqB;KACjC,CAAC;KAED,MAAM,cAAc,SAAS,QAAQ,IAAI,cAAc;KACvD,IAAI,CAAC,aAAa,WAAW,mBAAmB,GAC5C,MAAM,IAAI,MAAM,0DAA+D,aAAa;KAGhG,MAAM,SAAS,SAAS,MAAO,SAAS,YAAY,SAAS,CAAC,CAAC;KAE/D,MAAM,SAAS,OAAO;IAC1B,SAAS,KAAK;KACV,IAAI,CAAC,qBAAqB,OAAO,SAAS,qBAAqB,MAAM;KACrE,MAAM,SAAS,MAAM,GAAG;IAC5B;GACJ;GAEA,AAAK,OAAO;GAEZ,MAAM,WAAW;IAET,OAAyC;KACrC,MAAM,QAAQ,EAAE;KAChB,IAAI,OAAO,IAAI,QAAQ,CAAC,GAAG,OAAO,OAAO,QAAQ,CAAC;KAClD,IAAI,CAAC,OAAO,IAAI,KAAK,KAAK,CAAC,qBAAqB,OAAO,SAAS;MAC5D,MAAM,QAAQ,cAAmC;MACjD,OAAO,IAAI,OAAO;OAAE,GAAG;OAAO,MAAM;MAAM,CAAC;MAC3C,OAAO,MAAM;KACjB;KACA,IAAI,CAAC,OAAO,IAAI,KAAK,KAAK,qBAAqB,OAAO,SAAS;MAC3D,MAAM,QAAQ,cAAmC;MACjD,MAAM,QAAQ;OAAE,MAAM;OAAM,OAAO;MAAU,CAAC;MAC9C,OAAO,MAAM;KACjB;KACA,OAAO,OAAO,IAAI,KAAK,CAAC,CAAE;IAC9B;IACA,MAAM,SAAwC;KAC1C,IAAI,CAAC,qBAAqB,OAAO,SAAS,qBAAqB,MAAM;KACrE,KAAK,MAAM,CAAC,GAAG,aAAa,QAAQ,SAAS,QAAQ;MAAE,MAAM;MAAM,OAAO;KAAU,CAAC;KACrF,OAAO;MAAE,MAAM;MAAM,OAAO;KAAU;IAC1C;IACA,MAAM,MAAM,MAA0C;KAClD,IAAI,CAAC,qBAAqB,OAAO,SAAS,qBAAqB,MAAM;KACrE,KAAK,MAAM,CAAC,GAAG,aAAa,QAAQ,SAAS,QAAQ;MAAE,MAAM;MAAM,OAAO;KAAU,CAAC;KACrF,OAAO;MAAE,MAAM;MAAM,OAAO;KAAU;IAC1C;IAEJ,CAAC,OAAO,iBAAiB;KACrB,OAAO;IACX;GACJ;GAEA,IAAI;IACA,OAAO;GACX,SAAS,OAAO;IACZ,OAAO;GACX;EACJ,EACJ;EACA,kBAAkB,OAAO,KAAU,YAAiE;GAChG,MAAM,OAAO,WAAW,CAAC;GACzB,IAAI,KAAK,YAAY,QAAW,KAAK,UAAU,CAAC;GAChD,IAAI,KAAK,QAAQ,oBAAoB,QAAW,KAAK,QAAQ,kBAAkB;GAE/E,IAAI;GACJ,IAAI,CAAC,iBAAiB,kBAAkB,MAAM;GAE9C,IAAI;GACJ,IAAI,OAAO,SAAS,aAChB,aAAa,KAAK,GAAa;QAC5B,IAAI,OAAO,WAAW,aACzB,aAAa,OAAO,KAAK,GAAa,CAAC,CAAC,SAAS,QAAQ;QAEzD,MAAM,IAAI,MAAM,6BAA6B;GAEjD,MAAM,GAAG,gBAAgB,UAAU,mBAAmB,UAAU;GAEhE,IAAI;IACA,MAAM,OAAO,KAAK,UAAU,KAAK,MAAM,KAAK;IAE5C,MAAM,OAAO,OAAM,MADI,OAAO,KAAK;KAAE,QAAQ;KAAQ;KAAM,SAAS,KAAK;IAAQ,CAAC,EACvD,CAAC,KAAK;IACjC,MAAM,SAAS,gBAAgB,KAAK,MAAM,IAAI,CAAC;IAC/C,IAAI,OAAO,YAAY,MACnB,OAAO;KAAC,cAAc,OAAO,KAAK;KAAG;KAAM,EAAE,WAAW,OAAO,aAAa,GAAG;IAAC;IAEpF,OAAO;KAAC;KAAM,OAAO;KAAM,EAAE,WAAW,OAAO,UAAU;IAAC;GAC9D,QAAQ;IACJ,OAAO;KAAC,qBAAqB;KAAG;KAAM,EAAE,WAAW,UAAU;IAAC;GAClE;EACJ;EAEA,MAAM,KAAK,SAA+C;GAEtD,OAAO,MAAM,IAAI,QAAc,OAAO,YAAY;IAC9C,MAAM,MAAM,GAAG,MAAM,eAAe;IACpC,MAAM,UAAU,iBAAiB,WAAW,SAAS,WAAW;IAChE,MAAM,aAAa,KAAK,IAAI;IAC5B,MAAM,QAAQ,iBAAiB;KAE3B,QAAQ,CAAC;MAAE,SAAS;MAAO,OADV,KAAK,IACmB,IAAI;MAAY,OAAO,EAAE,iBAAiB;OAAE;OAAS,SAAS,yBAAyB,QAAQ;MAAK,EAAE;KAAE,GAAG,IAAI,CAAC;IAC7J,GAAG,OAAO;IAEV,IAAI;KACA,MAAM,WAAW,MAAM,OAAO,KAAK,EAAE,QAAQ,OAAO,CAAC;KACrD,MAAM,WAAW,KAAK,IAAI;KAC1B,aAAa,KAAK;KAClB,IAAI,SAAS,WAAW,KACpB,QAAQ,CAAC;MAAE,SAAS;MAAO,OAAO,WAAW;MAAY,OAAO,EAAE,cAAc;OAAE;OAAU,QAAQ,SAAS;OAAQ,SAAS;MAAsB,EAAE;KAAE,GAAG,IAAI,CAAC;KAGpK,QAAQ,CAAC,MAAM;MAAE,SAAS;MAAM,OAAO,WAAW;MAAY,iBAAiB,OAAO,SAAS,QAAQ,IAAI,cAAc,CAAC,CAAE,UAAU,EAAE,CAAC;KAAE,CAAC,CAAC;IACjJ,SAAS,OAAY;KAEjB,OAAO,CAAC;MAAE,SAAS;MAAO,OADT,KAAK,IACkB,IAAI;MAAY;KAAM,GAAG,IAAI;IACzE;GACJ,CAAC;EACL;EACA,QAAQ;CAiBE;AAClB;AAEA,MAAM,iBAAiB;AAEvB,SAAgB,gBAAmB,MAAY;CAC3C,IAAI,SAAS,QAAQ,SAAS,QAAW,OAAO;CAChD,MAAM,OAAO,OAAO;CACpB,IAAI,SAAS,UAAU;EACnB,IAAI,gBAAgB,MAAM,OAAO;EACjC,IAAI,MAAM,QAAQ,IAAI,GAAG;GACrB,MAAM,MAAM,KAAK;GACjB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK;IAC1B,MAAM,SAAS,gBAAgB,KAAK,EAAE;IACtC,IAAI,WAAW,KAAK,IAAI,KAAK,KAAK;GACtC;GACA,OAAO;EACX;EACA,MAAM,OAAO,OAAO,KAAK,IAAc;EACvC,MAAM,MAAM;EACZ,KAAK,MAAM,OAAO,MAAM;GACpB,MAAM,QAAQ,IAAI;GAClB,MAAM,SAAS,gBAAgB,KAAK;GACpC,IAAI,WAAW,OAAO,IAAI,OAAO;EACrC;EACA,OAAO;CACX;CACA,IAAI,SAAS,UAAU;EACnB,MAAM,MAAM;EAEZ,MAAM,MAAM,IAAI;EAChB,IAAI,OAAO,MAAM,OAAO,MAAM,IAAI,WAAW,CAAC,KAAK,MAAQ,IAAI,WAAW,CAAC,KAAK,MAAQ,IAAI,QAAQ,GAAG,MAAM,IAAI;GAC7G,MAAM,QAAQ,IAAI,MAAM,cAAc;GACtC,IAAI,UAAU,MAAM;IAChB,MAAM,WAAW,MAAM;IACvB,MAAM,SAAS,MAAM;IACrB,IAAI,WAAW,QAAW;KACtB,MAAM,WAAW,OAAO,WAAW,CAAC,MAAM,MAAM,UAAU,UAAU,KAAK,IAAI;KAC7E,IAAI,YAAY,GACZ,OAAO,IAAI,KAAK,IAAI,UAAU,GAAG,QAAQ,IAAI,IAAI,UAAU,WAAW,CAAC,CAAC;KAE5E,OAAO,IAAI,KAAK,GAAG;IACvB;IACA,IAAI,aAAa,QACb,uBAAO,IAAI,KAAK,WAAW,GAAG;GAEtC;EACJ;CACJ;CACA,OAAO;AACX;;;;;;;AAgEA,eAAsB,SAAS,QAAoC,SAAoC;CACnG,MAAM,SAAS,OAAO,UAAU;CAChC,IAAI;CAEJ,OAAO,EAAE,SAAS,MAAM,OAAO,KAAK,EAAC,CAAE,MACnC,QAAQ,OAAO,KAAK;AAE5B;;;;;;;AAQA,SAAgB,SAAS,QAAyD;CAC9E,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI,yBAAyB;CAG7B,OAAO,SAAS,QAAQ,KAAiB;EACrC,IAAI,WAAW,QAAW;GACtB,SAAS;GACT,WAAW;GACX,cAAc;EAClB,OAEI,SAAS,OAAO,QAAQ,GAAG;EAG/B,MAAM,YAAY,OAAO;EACzB,IAAI,YAAY;EAChB,OAAO,WAAW,WAAW;GACzB,IAAI,wBAAwB;IACxB,IAAI,OAAO,cAAc,IACrB,YAAY,EAAE;IAGlB,yBAAyB;GAC7B;GAGA,IAAI,UAAU;GACd,OAAO,WAAW,aAAa,YAAY,IAAI,EAAE,UAC7C,QAAQ,OAAO,WAAf;IACI,KAAK;KACD,IAAI,gBAAgB,IAEhB,cAAc,WAAW;KAE7B;IACJ,KAAK;KACD,yBAAyB;KACzB,UAAU;KACV;IAEJ,KAAK,IACD,UAAU;GAElB;GAGJ,IAAI,YAAY,IAGZ;GAIJ,OAAO,OAAO,SAAS,WAAW,OAAO,GAAG,WAAW;GACvD,YAAY;GACZ,cAAc;EAClB;EAEA,IAAI,cAAc,WACd,SAAS;OACN,IAAI,cAAc,GAAG;GAGxB,SAAS,OAAO,SAAS,SAAS;GAClC,YAAY;EAChB;CACJ;AACJ;;;;;;;;AASA,SAAgB,YAAY,WAA+C;CACvE,IAAI,UAAU,WAAW;CACzB,MAAM,UAAU,IAAI,YAAY;CAGhC,OAAO,SAAS,OAAO,MAAkB,aAAqB;EAC1D,IAAI,KAAK,WAAW,GAAG;GAEnB,YAAY,OAAO;GACnB,UAAU,WAAW;EACzB,OAAO,IAAI,cAAc,GAAG;GAIxB,MAAM,QAAQ,QAAQ,OAAO,KAAK,SAAS,GAAG,WAAW,CAAC;GAC1D,MAAM,cAAc,eAAe,KAAK,cAAc,OAAO,KAAK,IAAI;GACtE,MAAM,QAAQ,QAAQ,OAAO,KAAK,SAAS,WAAW,CAAC;GAEvD,QAAQ,OAAR;IACI,KAAK,QAGD,QAAQ,OAAO,QAAQ,OAAO,GAAG,QAAQ,KAAK,IAAI,UAAU;GAEpE;EACJ;CACJ;AACJ;AAEA,SAAS,OAAO,GAAe,GAAe;CAC1C,MAAM,MAAM,IAAI,WAAW,EAAE,SAAS,EAAE,MAAM;CAC9C,IAAI,IAAI,CAAC;CACT,IAAI,IAAI,GAAG,EAAE,MAAM;CACnB,OAAO;AACX;AAEA,SAAS,aAAiC;CACtC,OAAO,EACH,MAAM,GACV;AACJ;AASA,SAAgB,gBAAwD;CACpE,IAAI;CACJ,IAAI;CAKJ,OAAO;EAAE,aAJW,SAAY,KAAK,QAAQ;GACzC,UAAU;GACV,SAAS;EACb,CACe;EAAY;EAAkB;CAAQ;AACzD;AAEA,MAAM,UAAU;AAChB,MAAM,aAAa;AACnB,IAAI,aAAiC;AAErC,eAAe,SAA+B;CAC1C,IAAI,YAAY,OAAO;CAEvB,OAAO,IAAI,SAAS,SAAS,WAAW;EACpC,MAAM,UAAU,UAAU,KAAK,SAAS,CAAC;EACzC,QAAQ,gBAAgB,OAAO,QAAQ,KAAK;EAC5C,QAAQ,kBAAkB;GACtB,aAAa,QAAQ;GACrB,QAAQ,UAAU;EACtB;EACA,QAAQ,mBAAmB,UAAU;GACjC,MAAM,KAAM,MAAM,OAA4B;GAC9C,IAAI,CAAC,GAAG,iBAAiB,SAAS,UAAU,GACxC,GAAG,kBAAkB,UAAU;EAEvC;CACJ,CAAC;AACL;AAEA,eAAsB,0BAA0B,SAAmF;CAC/H,MAAM,OAAO;CAEb,IAAI,gBAAkC;CACtC,MAAM,0BAAU,IAAI,WAAW,EAAE;CAEjC,IAAI,SAAS,YAAY;EACrB,MAAM,YAAY,QAAQ,iBAAiB;EAC3C,IAAI,YAAY,CAAC,CAAC,OAAO,SAAS,CAAC,CAAC,SAAS,MAAM,MAAM;GACrD,IAAI,IAAI,IAAI,QAAQ,KAAK;EAC7B,CAAC;EAED,MAAM,UAAU,IAAI,YAAY;EAChC,MAAM,UAAU,QAAQ,OAAO,SAAS;EACxC,MAAM,cAAc,MAAM,OAAO,OAAO,UAAU,OAAO,SAAS,EAAE,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;EAE1G,gBAAgB,MAAM,OAAO,OAAO,UAChC;GACI,MAAM;GACN,MAAM,QAAQ,OAAO,uBAAuB;GAC5C,YAAY;GACZ,MAAM;EACV,GACA,aACA;GAAE,MAAM;GAAW,QAAQ;EAAI,GAC/B,OACA,CAAC,WAAW,SAAS,CACzB;CACJ;CAEA,MAAM,cAAc,OAAO,SAAmC;EAC1D,IAAI,CAAC,eAAe,OAAO;EAE3B,MAAM,aAAa,KAAK,UAAU,IAAI;EAEtC,MAAM,YAAY,IADE,YACI,CAAC,CAAC,OAAO,UAAU;EAE3C,MAAM,uBAAuB,MAAM,OAAO,OAAO,QAC7C;GACI,MAAM;GACG;GACT,QAAQ;EACZ,GACA,eACA,SACJ;EAEA,OAAO,IAAI,WAAW,oBAAoB;CAC9C;CAEA,MAAM,cAAc,OAAO,kBAA0D;EACjF,IAAI,CAAC,iBAAiB,CAAC,eAAe,OAAO;EAE7C,MAAM,cAAc,yBAAyB,aAAc,cAAc,SAAyB;EAElG,MAAM,iBAAiB,MAAM,OAAO,OAAO,QACvC;GACI,MAAM;GACG;GACT,QAAQ;EACZ,GACA,eACA,WACJ;EAGA,MAAM,aAAa,IADC,YACK,CAAC,CAAC,OAAO,cAAc;EAChD,OAAO,gBAAgB,KAAK,MAAM,UAAU,CAAC;CACjD;CAEA,OAAO;EACH,MAAM,IAAI,KAA+D;GACrE,MAAM,KAAK,MAAM,OAAO;GACxB,OAAO,IAAI,SAAS,SAAS,WAAW;IAGpC,MAAM,UAFc,GAAG,YAAY,YAAY,UACvB,CAAC,CAAC,YAAY,UAClB,CAAC,CAAC,IAAI,GAAG;IAC7B,QAAQ,gBAAgB,OAAO,QAAQ,KAAK;IAC5C,QAAQ,YAAY,YAAY;KAC5B,MAAM,SAAS,QAAQ;KACvB,IAAI,CAAC,QAAQ;MACT,QAAQ,IAAI;MACZ;KACJ;KAEA,IAAI,SAAS,eAAe,OAAO,gBAAgB,eAAe,OAAO,gBAAgB,aAAa;MAElG,QAAQ;OAAE,MAAM,MADY,YAAY,OAAO,IAAI;OACpB,WAAW,OAAO;MAAU,CAAC;MAC5D;KACJ;KAEA,QAAQ,UAAU,IAAI;IAC1B;GACJ,CAAC;EACL;EACA,MAAM,IAAI,KAAa,MAA0B;GAC7C,MAAM,KAAK,MAAM,OAAO;GACxB,IAAI,cAAmB;GAEvB,IAAI,SAAS,YACT,cAAc,MAAM,YAAY,IAAI;GAGxC,OAAO,IAAI,SAAS,SAAS,WAAW;IAGpC,MAAM,UAFc,GAAG,YAAY,YAAY,WACvB,CAAC,CAAC,YAAY,UAClB,CAAC,CAAC,IAAI;KAAE,MAAM;KAAa,WAAW,KAAK,IAAI;IAAE,GAAG,GAAG;IAC3E,QAAQ,gBAAgB,OAAO,QAAQ,KAAK;IAC5C,QAAQ,kBAAkB,QAAQ;GACtC,CAAC;EACL;CACJ;AACJ;AAEA,SAAS,iBAAiB,MAAc,QAAqB;CACzD,OAAO,GAAG,KAAK,GAAG,KAAK,UAAU,UAAU,CAAC,CAAC;AACjD"}