@tianacloud/dsh-remote 0.0.0-stage → 0.2.1

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.
@@ -0,0 +1,593 @@
1
+ /** Keyless streaming Service Worker bridge for `@tianacloud/dsh-remote` (zero keys, zero CacheStorage, per-window isolation, cold-restart navToken self-healing, CSP sandbox hardening). */
2
+
3
+ const portsByClientId = new Map(); // clientId -> { port: MessagePort, pending: Set<(err: Error) => void>, navToken: string }
4
+ const navTokenMap = new Map(); // navToken -> windowClientId
5
+ const workerOwnerByClientId = new Map(); // workerClientId -> ownerWindowClientId
6
+ const pendingClientWakeups = new Map(); // clientId -> Promise<entry | null>
7
+ const pendingNavWakeups = new Map(); // navToken -> Promise<{ entry, ownerClientId } | null>
8
+ const clientWaiters = new Map(); // clientId -> Set<(entry) => void>
9
+ const navWaiters = new Map(); // navToken -> Set<(resolved) => void>
10
+
11
+ const REBIND_TIMEOUT_MS = 3000;
12
+ const NAV_REBIND_TIMEOUT_MS = 2500;
13
+ const HEAD_TIMEOUT_MS = 60_000;
14
+ const SW_NAV_PARAM = '__dsh_nav';
15
+ const LEGACY_SW_NAV_PARAM = '__dsh_sw_nav';
16
+ const SW_DL_PARAM = '__dsh_dl';
17
+ const SW_NAV_HEADER = 'x-dsh-remote-nav';
18
+ const NAV_TOKEN_RE = /^[A-Za-z0-9_-]{24,64}$/u;
19
+
20
+ const SVG_SANDBOX_CSP = "sandbox; default-src 'none'; img-src data:; style-src 'unsafe-inline'";
21
+ const HTML_SANDBOX_CSP = "sandbox allow-scripts; default-src 'none'; img-src https: data: blob:; style-src https: 'unsafe-inline'; media-src https:; font-src https: data:";
22
+
23
+ function generateNavToken() {
24
+ return Array.from(crypto.getRandomValues(new Uint8Array(16)), (b) => b.toString(16).padStart(2, '0')).join('');
25
+ }
26
+ self.addEventListener('install', () => { self.skipWaiting(); });
27
+ self.addEventListener('activate', (event) => { event.waitUntil(self.clients.claim()); });
28
+ function getAppBasePath() {
29
+ try { const p = new URL(self.registration.scope).pathname; return p.endsWith('/') ? p : `${p}/`; } catch { return '/'; }
30
+ }
31
+ function isTrustedAppUrl(rawUrl) {
32
+ if (typeof rawUrl !== 'string' || !rawUrl) return false;
33
+ try {
34
+ const p = new URL(rawUrl);
35
+ if (p.origin !== self.location.origin) return false;
36
+ const base = getAppBasePath();
37
+ const baseNoSlash = base.length > 1 && base.endsWith('/') ? base.slice(0, -1) : base;
38
+ return p.pathname === baseNoSlash || p.pathname.startsWith(base);
39
+ } catch { return false; }
40
+ }
41
+ function isTrustedWindowClient(client) {
42
+ return Boolean(client && client.type === 'window' && typeof client.id === 'string' && client.id && isTrustedAppUrl(client.url));
43
+ }
44
+
45
+ function dropClientPort(clientId, reason = 'Service Worker bridge port closed') {
46
+ const entry = portsByClientId.get(clientId);
47
+ if (!entry) return;
48
+ portsByClientId.delete(clientId);
49
+ if (entry.navToken && navTokenMap.get(entry.navToken) === clientId) {
50
+ navTokenMap.delete(entry.navToken);
51
+ }
52
+ for (const [workerId, ownerId] of workerOwnerByClientId.entries()) {
53
+ if (ownerId === clientId) {
54
+ workerOwnerByClientId.delete(workerId);
55
+ }
56
+ }
57
+ const err = new Error(reason);
58
+ for (const failPending of entry.pending) {
59
+ try { failPending(err); } catch { /* ignore */ }
60
+ }
61
+ entry.pending.clear();
62
+ try { entry.port.close(); } catch { /* ignore */ }
63
+ }
64
+
65
+ function resolveClientWaiters(clientId, entry) {
66
+ const waiters = clientWaiters.get(clientId);
67
+ if (!waiters) return;
68
+ clientWaiters.delete(clientId);
69
+ for (const fn of [...waiters]) {
70
+ try { fn(entry); } catch { /* ignore */ }
71
+ }
72
+ }
73
+
74
+ function resolveNavWaiters(navToken, resolved) {
75
+ const waiters = navWaiters.get(navToken);
76
+ if (!waiters) return;
77
+ navWaiters.delete(navToken);
78
+ for (const fn of [...waiters]) {
79
+ try { fn(resolved); } catch { /* ignore */ }
80
+ }
81
+ }
82
+
83
+ self.addEventListener('message', (event) => {
84
+ const data = event.data;
85
+ if (!data || typeof data !== 'object') return;
86
+ const source = event.source;
87
+ if (!isTrustedWindowClient(source)) return;
88
+ const clientId = source.id;
89
+
90
+ if (data.type === 'dsh-remote:sw-bind' && event.ports && event.ports[0]) {
91
+ if (data.clientId && data.clientId !== clientId) return;
92
+ const requestedToken = typeof data.navToken === 'string' && NAV_TOKEN_RE.test(data.navToken)
93
+ ? data.navToken
94
+ : '';
95
+ const navToken = requestedToken || generateNavToken();
96
+ const existingOwner = navTokenMap.get(navToken);
97
+ if (existingOwner && existingOwner !== clientId && portsByClientId.has(existingOwner)) {
98
+ return;
99
+ }
100
+
101
+ const port = event.ports[0];
102
+ const prev = portsByClientId.get(clientId);
103
+ if (prev && prev.port !== port) {
104
+ dropClientPort(clientId, 'Service Worker bridge port replaced');
105
+ }
106
+ const entry = { port, pending: new Set(), navToken };
107
+ port.addEventListener?.('messageerror', () => {
108
+ if (portsByClientId.get(clientId) === entry) {
109
+ dropClientPort(clientId, 'Service Worker bridge port message error');
110
+ }
111
+ });
112
+ portsByClientId.set(clientId, entry);
113
+ navTokenMap.set(navToken, clientId);
114
+ port.start?.();
115
+ port.postMessage({ type: 'dsh-remote:sw-bound', clientId, navToken });
116
+ resolveClientWaiters(clientId, entry);
117
+ resolveNavWaiters(navToken, { entry, ownerClientId: clientId });
118
+ return;
119
+ }
120
+
121
+ if (data.type === 'dsh-remote:sw-unbind') {
122
+ if (data.clientId && data.clientId !== clientId) return;
123
+ const prevNavToken = portsByClientId.get(clientId)?.navToken || '';
124
+ dropClientPort(clientId, 'Service Worker bridge unbound');
125
+ resolveClientWaiters(clientId, null);
126
+ if (prevNavToken) resolveNavWaiters(prevNavToken, null);
127
+ }
128
+ });
129
+
130
+ function shouldPassthrough(request, url, appBase) {
131
+ if (url.origin !== self.location.origin) return true;
132
+ const pathname = url.pathname;
133
+ const appBaseNoSlash = appBase.length > 1 && appBase.endsWith('/') ? appBase.slice(0, -1) : appBase;
134
+
135
+ if (pathname.startsWith(`${appBase}_tiana/`) ||
136
+ pathname.startsWith('/_tiana/') ||
137
+ pathname.startsWith(`${appBase}assets/`) ||
138
+ pathname.startsWith('/brand/') ||
139
+ pathname === '/favicon.ico') {
140
+ return true;
141
+ }
142
+ if (request.mode === 'navigate' && (pathname === appBase || pathname === appBaseNoSlash)) {
143
+ return true;
144
+ }
145
+ if (appBase !== '/' && !pathname.startsWith(appBase) && pathname !== appBaseNoSlash &&
146
+ !pathname.startsWith('/api/') && pathname !== '/api' &&
147
+ !pathname.startsWith('/plugins/') && pathname !== '/plugins') {
148
+ return true;
149
+ }
150
+ return false;
151
+ }
152
+
153
+ function extractNavToken(request, url) {
154
+ const fromQuery = url.searchParams.get(SW_NAV_PARAM) || url.searchParams.get(LEGACY_SW_NAV_PARAM) || '';
155
+ if (fromQuery && NAV_TOKEN_RE.test(fromQuery)) return fromQuery;
156
+ const fromHeader = request.headers.get(SW_NAV_HEADER) || '';
157
+ if (fromHeader && NAV_TOKEN_RE.test(fromHeader)) return fromHeader;
158
+ return '';
159
+ }
160
+
161
+ function resolveTunnelPath(url, appBase) {
162
+ let pathname = url.pathname;
163
+ if (appBase !== '/' && pathname.startsWith(appBase)) {
164
+ pathname = `/${pathname.slice(appBase.length)}`;
165
+ }
166
+ const params = new URLSearchParams(url.search);
167
+ params.delete(SW_NAV_PARAM);
168
+ params.delete(LEGACY_SW_NAV_PARAM);
169
+ params.delete(SW_DL_PARAM);
170
+ const qs = params.toString();
171
+ return qs ? `${pathname}?${qs}` : pathname;
172
+ }
173
+
174
+ function hardenHeaders(rawHeaders, downloadParam = '') {
175
+ const headers = new Headers(rawHeaders || {});
176
+ headers.set('x-content-type-options', 'nosniff');
177
+ headers.set('cache-control', 'no-store');
178
+ if (downloadParam) {
179
+ const safeName = downloadParam === '1' ? '' : downloadParam.replace(/[\r\n"\\\/]/gu, '_').slice(0, 180);
180
+ const existing = String(headers.get('content-disposition') || '');
181
+ if (safeName) {
182
+ headers.set('content-disposition', `attachment; filename="${safeName}"`);
183
+ } else if (!/^attachment\b/iu.test(existing)) {
184
+ headers.set('content-disposition', 'attachment');
185
+ }
186
+ }
187
+
188
+ const rawType = String(headers.get('content-type') || '');
189
+ const mediaType = rawType.split(';', 1)[0].trim().toLowerCase();
190
+
191
+ if (mediaType === 'image/svg+xml') {
192
+ // Append enforces intersection with any stricter upstream CSP while always stripping allow-same-origin
193
+ headers.append('content-security-policy', SVG_SANDBOX_CSP);
194
+ } else if (mediaType === 'text/html' || mediaType === 'application/xhtml+xml') {
195
+ headers.append('content-security-policy', HTML_SANDBOX_CSP);
196
+ }
197
+ return headers;
198
+ }
199
+
200
+ function resolvePortForClientId(targetClientId) {
201
+ if (!targetClientId) return Promise.resolve(null);
202
+
203
+ const existing = portsByClientId.get(targetClientId);
204
+ if (existing) return Promise.resolve(existing);
205
+
206
+ const inflight = pendingClientWakeups.get(targetClientId);
207
+ if (inflight) return inflight;
208
+
209
+ const promise = (async () => {
210
+ let client = null;
211
+ try {
212
+ client = await self.clients.get(targetClientId);
213
+ } catch {
214
+ return null;
215
+ }
216
+ if (!isTrustedWindowClient(client)) {
217
+ return null;
218
+ }
219
+ const alreadyBound = portsByClientId.get(targetClientId);
220
+ if (alreadyBound) return alreadyBound;
221
+
222
+ return await new Promise((resolve) => {
223
+ let settled = false;
224
+ let timer = null;
225
+ const finish = (entry) => {
226
+ if (settled) return;
227
+ settled = true;
228
+ clearTimeout(timer);
229
+ const set = clientWaiters.get(targetClientId);
230
+ if (set) {
231
+ set.delete(finish);
232
+ if (set.size === 0) clientWaiters.delete(targetClientId);
233
+ }
234
+ resolve(entry || null);
235
+ };
236
+ let set = clientWaiters.get(targetClientId);
237
+ if (!set) {
238
+ set = new Set();
239
+ clientWaiters.set(targetClientId, set);
240
+ }
241
+ set.add(finish);
242
+ timer = setTimeout(() => finish(null), REBIND_TIMEOUT_MS);
243
+ try {
244
+ client.postMessage({ type: 'dsh-remote:sw-request-port', clientId: targetClientId });
245
+ } catch {
246
+ finish(null);
247
+ }
248
+ });
249
+ })().finally(() => {
250
+ if (pendingClientWakeups.get(targetClientId) === promise) {
251
+ pendingClientWakeups.delete(targetClientId);
252
+ }
253
+ });
254
+
255
+ pendingClientWakeups.set(targetClientId, promise);
256
+ return promise;
257
+ }
258
+
259
+ function resolvePortByNavToken(navToken) {
260
+ if (!navToken || !NAV_TOKEN_RE.test(navToken)) return Promise.resolve(null);
261
+
262
+ const inflight = pendingNavWakeups.get(navToken);
263
+ if (inflight) return inflight;
264
+
265
+ const promise = (async () => {
266
+ const ownerClientId = navTokenMap.get(navToken);
267
+ if (ownerClientId) {
268
+ const entry = portsByClientId.get(ownerClientId);
269
+ if (entry && entry.navToken === navToken) {
270
+ let ownerClient = null;
271
+ try {
272
+ ownerClient = await self.clients.get(ownerClientId);
273
+ } catch {
274
+ ownerClient = null;
275
+ }
276
+ if (isTrustedWindowClient(ownerClient)) {
277
+ return { entry, ownerClientId };
278
+ }
279
+ dropClientPort(ownerClientId, 'Service Worker owning window closed');
280
+ }
281
+ }
282
+
283
+ // Cold SW restart self-healing: ask controlled in-scope WindowClients to re-bind if they own navToken.
284
+ let windowClients = [];
285
+ try {
286
+ windowClients = await self.clients.matchAll({ type: 'window', includeUncontrolled: false });
287
+ } catch {
288
+ return null;
289
+ }
290
+
291
+ const boundOwnerId = navTokenMap.get(navToken);
292
+ if (boundOwnerId) {
293
+ const boundEntry = portsByClientId.get(boundOwnerId);
294
+ if (boundEntry && boundEntry.navToken === navToken) {
295
+ return { entry: boundEntry, ownerClientId: boundOwnerId };
296
+ }
297
+ }
298
+
299
+ const trustedWindows = windowClients.filter((c) => isTrustedWindowClient(c));
300
+ if (trustedWindows.length === 0) return null;
301
+
302
+ const resolved = await new Promise((resolve) => {
303
+ let settled = false;
304
+ let timer = null;
305
+ const finish = (val) => {
306
+ if (settled) return;
307
+ settled = true;
308
+ clearTimeout(timer);
309
+ const set = navWaiters.get(navToken);
310
+ if (set) {
311
+ set.delete(finish);
312
+ if (set.size === 0) navWaiters.delete(navToken);
313
+ }
314
+ resolve(val || null);
315
+ };
316
+ let set = navWaiters.get(navToken);
317
+ if (!set) {
318
+ set = new Set();
319
+ navWaiters.set(navToken, set);
320
+ }
321
+ set.add(finish);
322
+ timer = setTimeout(() => finish(null), NAV_REBIND_TIMEOUT_MS);
323
+
324
+ let sentCount = 0;
325
+ for (const win of trustedWindows) {
326
+ try {
327
+ win.postMessage({ type: 'dsh-remote:sw-request-port', requestedNavToken: navToken });
328
+ sentCount += 1;
329
+ } catch {
330
+ // ignore closed window
331
+ }
332
+ }
333
+ if (sentCount === 0) {
334
+ finish(null);
335
+ }
336
+ });
337
+
338
+ if (!resolved?.entry || resolved.entry.navToken !== navToken) return null;
339
+ return resolved;
340
+ })().finally(() => {
341
+ if (pendingNavWakeups.get(navToken) === promise) {
342
+ pendingNavWakeups.delete(navToken);
343
+ }
344
+ });
345
+
346
+ pendingNavWakeups.set(navToken, promise);
347
+ return promise;
348
+ }
349
+
350
+ async function resolvePortForEvent(event, url) {
351
+ const directClientId = event.clientId || '';
352
+ if (directClientId) {
353
+ const existingDirect = portsByClientId.get(directClientId);
354
+ if (existingDirect) return existingDirect;
355
+
356
+ const cachedWorkerOwner = workerOwnerByClientId.get(directClientId);
357
+ if (cachedWorkerOwner) {
358
+ const ownerPort = await resolvePortForClientId(cachedWorkerOwner);
359
+ if (ownerPort) return ownerPort;
360
+ workerOwnerByClientId.delete(directClientId);
361
+ }
362
+
363
+ const directPort = await resolvePortForClientId(directClientId);
364
+ if (directPort) return directPort;
365
+ }
366
+
367
+ const navToken = extractNavToken(event.request, url);
368
+ if (navToken) {
369
+ const dest = event.request.destination || '';
370
+ const referrer = event.request.referrer || '';
371
+ if ((dest === 'iframe' || dest === 'frame') && !isTrustedAppUrl(referrer)) {
372
+ return null;
373
+ }
374
+ if (referrer && (referrer.startsWith('http://') || referrer.startsWith('https://')) && !isTrustedAppUrl(referrer)) {
375
+ return null;
376
+ }
377
+ const resolved = await resolvePortByNavToken(navToken);
378
+ if (resolved?.entry) {
379
+ if (directClientId && directClientId !== resolved.ownerClientId) {
380
+ workerOwnerByClientId.set(directClientId, resolved.ownerClientId);
381
+ }
382
+ return resolved.entry;
383
+ }
384
+ return null;
385
+ }
386
+
387
+ if (directClientId) return null;
388
+ const resultingClientId = event.resultingClientId || '';
389
+ if (!resultingClientId) return null;
390
+ return await resolvePortForClientId(resultingClientId);
391
+ }
392
+
393
+ function unavailablePortResponse() {
394
+ return new Response(
395
+ JSON.stringify({ ok: false, error: 'Service Worker tunnel bridge is unavailable for this window' }),
396
+ {
397
+ status: 503,
398
+ headers: {
399
+ 'content-type': 'application/json; charset=utf-8',
400
+ 'cache-control': 'no-store',
401
+ 'x-content-type-options': 'nosniff',
402
+ 'content-security-policy': "sandbox; default-src 'none'",
403
+ },
404
+ },
405
+ );
406
+ }
407
+
408
+ async function handleTunneledFetch(request, tunnelPath, portEntry, downloadParam = '') {
409
+ const method = (request.method || 'GET').toUpperCase();
410
+ const headersObj = {};
411
+ request.headers.forEach((value, key) => {
412
+ if (key.toLowerCase() === SW_NAV_HEADER) return;
413
+ headersObj[key] = value;
414
+ });
415
+
416
+ let bodyBuf = null;
417
+ if (method !== 'GET' && method !== 'HEAD') {
418
+ bodyBuf = await request.arrayBuffer();
419
+ }
420
+
421
+ return await new Promise((resolveResponse, rejectResponse) => {
422
+ const channel = new MessageChannel();
423
+ const reqPort = channel.port1;
424
+ let settled = false;
425
+ let closed = false;
426
+ let streamController = null;
427
+ let pendingPulls = 0;
428
+ let headTimer = null;
429
+
430
+ const cleanup = () => {
431
+ if (closed) return;
432
+ closed = true;
433
+ clearTimeout(headTimer);
434
+ headTimer = null;
435
+ portEntry.pending.delete(failRequest);
436
+ request.signal?.removeEventListener('abort', onAbort);
437
+ try { reqPort.close(); } catch { /* ignore */ }
438
+ };
439
+
440
+ const failRequest = (err) => {
441
+ cleanup();
442
+ if (!settled) {
443
+ settled = true;
444
+ rejectResponse(err);
445
+ } else if (streamController) {
446
+ try { streamController.error(err); } catch { /* ignore */ }
447
+ }
448
+ };
449
+
450
+ const sendAbort = () => {
451
+ if (!closed) {
452
+ try { reqPort.postMessage({ type: 'abort' }); } catch { /* ignore */ }
453
+ }
454
+ cleanup();
455
+ };
456
+
457
+ const onAbort = () => {
458
+ sendAbort();
459
+ failRequest(new DOMException('Aborted', 'AbortError'));
460
+ };
461
+
462
+ if (request.signal?.aborted) {
463
+ onAbort();
464
+ return;
465
+ }
466
+ request.signal?.addEventListener('abort', onAbort, { once: true });
467
+ portEntry.pending.add(failRequest);
468
+
469
+ headTimer = setTimeout(() => {
470
+ sendAbort();
471
+ failRequest(new Error('Tunneled subresource response header timed out'));
472
+ }, HEAD_TIMEOUT_MS);
473
+
474
+ const requestPull = () => {
475
+ if (closed) return;
476
+ while (pendingPulls < 4) {
477
+ pendingPulls += 1;
478
+ try { reqPort.postMessage({ type: 'pull' }); } catch { break; }
479
+ }
480
+ };
481
+
482
+ reqPort.onmessageerror = () => {
483
+ sendAbort();
484
+ failRequest(new Error('Service Worker bridge port message error'));
485
+ };
486
+
487
+ reqPort.onmessage = (ev) => {
488
+ const msg = ev.data;
489
+ if (!msg || typeof msg !== 'object') return;
490
+
491
+ if (msg.type === 'head') {
492
+ if (settled) return;
493
+ clearTimeout(headTimer);
494
+ headTimer = null;
495
+ const status = Number(msg.status) || 200;
496
+ const headers = hardenHeaders(msg.headers, downloadParam);
497
+ const emptyBody = status === 204 || status === 205 || status === 304 || method === 'HEAD';
498
+
499
+ if (emptyBody) {
500
+ settled = true;
501
+ cleanup();
502
+ resolveResponse(new Response(null, { status, statusText: msg.statusText || '', headers }));
503
+ return;
504
+ }
505
+
506
+ const bodyStream = new ReadableStream({
507
+ start(controller) {
508
+ streamController = controller;
509
+ requestPull();
510
+ },
511
+ pull() {
512
+ requestPull();
513
+ },
514
+ cancel() {
515
+ sendAbort();
516
+ },
517
+ });
518
+
519
+ settled = true;
520
+ resolveResponse(new Response(bodyStream, {
521
+ status,
522
+ statusText: msg.statusText || '',
523
+ headers,
524
+ }));
525
+ return;
526
+ }
527
+
528
+ if (msg.type === 'chunk') {
529
+ if (pendingPulls > 0) pendingPulls -= 1;
530
+ const bytes = msg.data instanceof Uint8Array ? msg.data : new Uint8Array(msg.data);
531
+ if (streamController && !closed) {
532
+ try {
533
+ streamController.enqueue(bytes);
534
+ reqPort.postMessage({ type: 'consumed', bytes: bytes.byteLength });
535
+ } catch {
536
+ sendAbort();
537
+ return;
538
+ }
539
+ if ((streamController.desiredSize ?? 0) > 0) {
540
+ requestPull();
541
+ }
542
+ }
543
+ return;
544
+ }
545
+
546
+ if (msg.type === 'end') {
547
+ if (streamController && !closed) {
548
+ try { streamController.close(); } catch { /* ignore */ }
549
+ }
550
+ cleanup();
551
+ return;
552
+ }
553
+
554
+ if (msg.type === 'error') {
555
+ failRequest(new Error(msg.message || 'Tunneled subresource fetch failed'));
556
+ }
557
+ };
558
+
559
+ reqPort.start?.();
560
+ const transfer = [channel.port2];
561
+ if (bodyBuf && bodyBuf.byteLength > 0) transfer.push(bodyBuf);
562
+ try {
563
+ portEntry.port.postMessage({
564
+ type: 'fetch',
565
+ method,
566
+ path: tunnelPath,
567
+ headers: headersObj,
568
+ body: bodyBuf,
569
+ redirect: request.redirect || 'follow',
570
+ mode: request.mode || 'cors',
571
+ }, transfer);
572
+ } catch (err) {
573
+ failRequest(err instanceof Error ? err : new Error(String(err)));
574
+ }
575
+ });
576
+ }
577
+
578
+ self.addEventListener('fetch', (event) => {
579
+ const url = new URL(event.request.url);
580
+ const appBase = getAppBasePath();
581
+ if (shouldPassthrough(event.request, url, appBase)) {
582
+ return;
583
+ }
584
+ const downloadParam = url.searchParams.get(SW_DL_PARAM) || '';
585
+ const tunnelPath = resolveTunnelPath(url, appBase);
586
+ event.respondWith((async () => {
587
+ const portEntry = await resolvePortForEvent(event, url);
588
+ if (!portEntry) {
589
+ return unavailablePortResponse();
590
+ }
591
+ return await handleTunneledFetch(event.request, tunnelPath, portEntry, downloadParam);
592
+ })());
593
+ });