xote 4.16.1 → 5.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -2
- package/dist/xote.cjs +7 -7
- package/dist/xote.mjs +579 -574
- package/dist/xote.umd.js +5 -5
- package/package.json +2 -2
- package/src/Xote.res.mjs +3 -0
- package/src/Xote__Component.res +5 -5
- package/src/Xote__Component.res.mjs +5 -5
- package/src/Xote__Hydration.res +9 -9
- package/src/Xote__Hydration.res.mjs +9 -9
package/dist/xote.mjs
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
let Me = {
|
|
2
2
|
contents: 0
|
|
3
3
|
};
|
|
4
|
-
function
|
|
4
|
+
function De() {
|
|
5
5
|
return Me.contents = Me.contents + 1 | 0, Me.contents;
|
|
6
6
|
}
|
|
7
7
|
function lt() {
|
|
@@ -16,7 +16,7 @@ function lt() {
|
|
|
16
16
|
level: 0
|
|
17
17
|
};
|
|
18
18
|
}
|
|
19
|
-
function
|
|
19
|
+
function ln(e) {
|
|
20
20
|
return {
|
|
21
21
|
first: void 0,
|
|
22
22
|
last: void 0,
|
|
@@ -28,7 +28,7 @@ function rn(e) {
|
|
|
28
28
|
level: 0
|
|
29
29
|
};
|
|
30
30
|
}
|
|
31
|
-
function
|
|
31
|
+
function un(e, t, n, r, i) {
|
|
32
32
|
return {
|
|
33
33
|
id: e,
|
|
34
34
|
kind: t,
|
|
@@ -44,28 +44,28 @@ function ln(e, t, n, r, i) {
|
|
|
44
44
|
function it(e) {
|
|
45
45
|
e.flags = e.flags & -2;
|
|
46
46
|
}
|
|
47
|
-
function
|
|
47
|
+
function on(e) {
|
|
48
48
|
return (e.flags & 2) !== 0;
|
|
49
49
|
}
|
|
50
|
-
function
|
|
50
|
+
function dn(e) {
|
|
51
51
|
e.flags = e.flags | 2;
|
|
52
52
|
}
|
|
53
|
-
function
|
|
53
|
+
function an(e) {
|
|
54
54
|
e.flags = e.flags & -3;
|
|
55
55
|
}
|
|
56
56
|
function ut(e) {
|
|
57
57
|
return (e.flags & 1) !== 0;
|
|
58
58
|
}
|
|
59
|
-
function
|
|
59
|
+
function sn(e) {
|
|
60
60
|
e.flags = e.flags | 1;
|
|
61
61
|
}
|
|
62
|
-
function
|
|
62
|
+
function We(e) {
|
|
63
63
|
e.flags = e.flags & -2;
|
|
64
64
|
}
|
|
65
65
|
function cn(e) {
|
|
66
66
|
e.flags = e.flags & -3;
|
|
67
67
|
}
|
|
68
|
-
function
|
|
68
|
+
function xe(e) {
|
|
69
69
|
return e.compute !== void 0;
|
|
70
70
|
}
|
|
71
71
|
function Ze(e, t) {
|
|
@@ -105,7 +105,7 @@ function dt(e) {
|
|
|
105
105
|
}
|
|
106
106
|
e.firstDep = void 0, e.lastDep = void 0;
|
|
107
107
|
}
|
|
108
|
-
function
|
|
108
|
+
function Ie(e) {
|
|
109
109
|
let t = e.firstDep;
|
|
110
110
|
for (; t !== void 0; ) {
|
|
111
111
|
let n = t;
|
|
@@ -128,7 +128,7 @@ function te(e) {
|
|
|
128
128
|
BS_PRIVATE_NESTED_SOME_NONE: e.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0
|
|
129
129
|
} : e;
|
|
130
130
|
}
|
|
131
|
-
function
|
|
131
|
+
function Ge(e) {
|
|
132
132
|
if (e != null)
|
|
133
133
|
return te(e);
|
|
134
134
|
}
|
|
@@ -141,17 +141,17 @@ function S(e) {
|
|
|
141
141
|
BS_PRIVATE_NESTED_SOME_NONE: t - 1 | 0
|
|
142
142
|
};
|
|
143
143
|
}
|
|
144
|
-
function
|
|
144
|
+
function fn(e, t) {
|
|
145
145
|
if (e !== void 0)
|
|
146
146
|
return te(t(S(e)));
|
|
147
147
|
}
|
|
148
148
|
function V(e, t) {
|
|
149
149
|
return e !== void 0 ? S(e) : t;
|
|
150
150
|
}
|
|
151
|
-
function
|
|
151
|
+
function ze(e) {
|
|
152
152
|
return e !== void 0;
|
|
153
153
|
}
|
|
154
|
-
let
|
|
154
|
+
let A = {
|
|
155
155
|
contents: void 0
|
|
156
156
|
}, L = {
|
|
157
157
|
contents: void 0
|
|
@@ -160,13 +160,13 @@ let C = {
|
|
|
160
160
|
}, we = [], nt = (function(e) {
|
|
161
161
|
e.length = 0;
|
|
162
162
|
});
|
|
163
|
-
function
|
|
164
|
-
if (!
|
|
165
|
-
|
|
163
|
+
function pn(e) {
|
|
164
|
+
if (!on(e)) {
|
|
165
|
+
dn(e), Y.push(e);
|
|
166
166
|
return;
|
|
167
167
|
}
|
|
168
168
|
}
|
|
169
|
-
function
|
|
169
|
+
function hn(e, t) {
|
|
170
170
|
if (e.firstDep === void 0) {
|
|
171
171
|
let l = {
|
|
172
172
|
subs: t,
|
|
@@ -210,55 +210,55 @@ function mn(e, t) {
|
|
|
210
210
|
let i = Ze(t, e);
|
|
211
211
|
et(e, i), ve(t, i);
|
|
212
212
|
}
|
|
213
|
-
function
|
|
214
|
-
let t =
|
|
213
|
+
function gn(e) {
|
|
214
|
+
let t = A.contents;
|
|
215
215
|
if (t !== void 0)
|
|
216
|
-
return
|
|
216
|
+
return hn(t, e);
|
|
217
217
|
let n = L.contents;
|
|
218
218
|
if (n !== void 0)
|
|
219
219
|
return mn(n, e);
|
|
220
220
|
}
|
|
221
|
-
function
|
|
221
|
+
function Sn(e, t) {
|
|
222
222
|
return e.level - t.level | 0;
|
|
223
223
|
}
|
|
224
|
-
function
|
|
224
|
+
function _n(e, t) {
|
|
225
225
|
return e.level - t.level | 0;
|
|
226
226
|
}
|
|
227
227
|
function at(e) {
|
|
228
228
|
let t = 0, n = e.firstDep;
|
|
229
229
|
for (; n !== void 0; ) {
|
|
230
230
|
let r = n;
|
|
231
|
-
r !== void 0 && (
|
|
231
|
+
r !== void 0 && (xe(r.subs) && r.subs.level > t && (t = r.subs.level), n = r.nextDep);
|
|
232
232
|
}
|
|
233
233
|
return t + 1 | 0;
|
|
234
234
|
}
|
|
235
|
-
function
|
|
235
|
+
function st(e) {
|
|
236
236
|
let t = 0, n = e.firstDep;
|
|
237
237
|
for (; n !== void 0; ) {
|
|
238
238
|
let r = n;
|
|
239
|
-
r !== void 0 && (
|
|
239
|
+
r !== void 0 && (xe(r.subs) && r.subs.level > t && (t = r.subs.level), n = r.nextDep);
|
|
240
240
|
}
|
|
241
241
|
return t + 1 | 0;
|
|
242
242
|
}
|
|
243
|
-
function
|
|
243
|
+
function yn(e) {
|
|
244
244
|
let t = e.level;
|
|
245
|
-
|
|
246
|
-
let n =
|
|
247
|
-
|
|
245
|
+
Ie(e), cn(e);
|
|
246
|
+
let n = A.contents;
|
|
247
|
+
A.contents = e;
|
|
248
248
|
try {
|
|
249
249
|
let r = e.compute;
|
|
250
|
-
r !== void 0 && r(),
|
|
250
|
+
r !== void 0 && r(), We(e), A.contents = n;
|
|
251
251
|
} catch (r) {
|
|
252
|
-
throw
|
|
252
|
+
throw A.contents = n, r;
|
|
253
253
|
}
|
|
254
254
|
if (t === 0) {
|
|
255
255
|
e.level = at(e);
|
|
256
256
|
return;
|
|
257
257
|
}
|
|
258
258
|
}
|
|
259
|
-
function
|
|
259
|
+
function bn(e) {
|
|
260
260
|
let t = e.level;
|
|
261
|
-
dt(e),
|
|
261
|
+
dt(e), an(e);
|
|
262
262
|
let n = L.contents;
|
|
263
263
|
L.contents = e;
|
|
264
264
|
try {
|
|
@@ -267,23 +267,23 @@ function yn(e) {
|
|
|
267
267
|
throw L.contents = n, r;
|
|
268
268
|
}
|
|
269
269
|
if (t === 0) {
|
|
270
|
-
e.level =
|
|
270
|
+
e.level = st(e);
|
|
271
271
|
return;
|
|
272
272
|
}
|
|
273
273
|
}
|
|
274
|
-
function
|
|
274
|
+
function ct() {
|
|
275
275
|
J.contents = !0;
|
|
276
276
|
try {
|
|
277
277
|
for (; Y.length !== 0 || ee.length !== 0; ) {
|
|
278
278
|
if (ee.length !== 0) {
|
|
279
|
-
ee.sort(
|
|
279
|
+
ee.sort(_n);
|
|
280
280
|
let e = ee.slice();
|
|
281
|
-
nt(ee), e.forEach(
|
|
281
|
+
nt(ee), e.forEach(yn);
|
|
282
282
|
}
|
|
283
283
|
if (Y.length !== 0) {
|
|
284
|
-
Y.sort(
|
|
284
|
+
Y.sort(Sn);
|
|
285
285
|
let e = Y.slice();
|
|
286
|
-
nt(Y), e.forEach(
|
|
286
|
+
nt(Y), e.forEach(bn);
|
|
287
287
|
}
|
|
288
288
|
}
|
|
289
289
|
J.contents = !1;
|
|
@@ -292,7 +292,7 @@ function st() {
|
|
|
292
292
|
throw J.contents = !1, e;
|
|
293
293
|
}
|
|
294
294
|
}
|
|
295
|
-
function
|
|
295
|
+
function En(e) {
|
|
296
296
|
for (we.push(e); we.length !== 0; ) {
|
|
297
297
|
let t = we.pop();
|
|
298
298
|
if (t !== void 0) {
|
|
@@ -301,74 +301,74 @@ function bn(e) {
|
|
|
301
301
|
let r = n;
|
|
302
302
|
if (r !== void 0) {
|
|
303
303
|
let i = r.observer;
|
|
304
|
-
|
|
304
|
+
xe(i) ? ut(i) || (sn(i), we.push(i)) : pn(r.observer), n = r.nextSub;
|
|
305
305
|
}
|
|
306
306
|
}
|
|
307
307
|
}
|
|
308
308
|
}
|
|
309
309
|
if ((Y.length !== 0 || ee.length !== 0) && !J.contents)
|
|
310
|
-
return
|
|
310
|
+
return ct();
|
|
311
311
|
}
|
|
312
312
|
function ft(e) {
|
|
313
|
-
if (!(
|
|
313
|
+
if (!(xe(e) && ut(e)))
|
|
314
314
|
return;
|
|
315
315
|
let t = e.level;
|
|
316
|
-
|
|
317
|
-
let n =
|
|
318
|
-
|
|
316
|
+
Ie(e);
|
|
317
|
+
let n = A.contents;
|
|
318
|
+
A.contents = e;
|
|
319
319
|
try {
|
|
320
320
|
let r = e.compute;
|
|
321
|
-
r !== void 0 && r(),
|
|
321
|
+
r !== void 0 && r(), We(e), A.contents = n;
|
|
322
322
|
} catch (r) {
|
|
323
|
-
throw
|
|
323
|
+
throw A.contents = n, r;
|
|
324
324
|
}
|
|
325
325
|
if (t === 0) {
|
|
326
326
|
e.level = at(e);
|
|
327
327
|
return;
|
|
328
328
|
}
|
|
329
329
|
}
|
|
330
|
-
function
|
|
330
|
+
function wn(e) {
|
|
331
331
|
let t = J.contents;
|
|
332
332
|
J.contents = !0;
|
|
333
333
|
try {
|
|
334
334
|
let n = e();
|
|
335
|
-
return t || (J.contents = !1, (Y.length !== 0 || ee.length !== 0) &&
|
|
335
|
+
return t || (J.contents = !1, (Y.length !== 0 || ee.length !== 0) && ct()), n;
|
|
336
336
|
} catch (n) {
|
|
337
337
|
throw t || (J.contents = !1), n;
|
|
338
338
|
}
|
|
339
339
|
}
|
|
340
|
-
function
|
|
341
|
-
let t =
|
|
342
|
-
|
|
340
|
+
function kn(e) {
|
|
341
|
+
let t = A.contents, n = L.contents;
|
|
342
|
+
A.contents = void 0, L.contents = void 0;
|
|
343
343
|
try {
|
|
344
344
|
let r = e();
|
|
345
|
-
return
|
|
345
|
+
return A.contents = t, L.contents = n, r;
|
|
346
346
|
} catch (r) {
|
|
347
|
-
throw
|
|
347
|
+
throw A.contents = t, L.contents = n, r;
|
|
348
348
|
}
|
|
349
349
|
}
|
|
350
|
-
function
|
|
350
|
+
function Tn(e, t, n) {
|
|
351
351
|
return {
|
|
352
|
-
id:
|
|
352
|
+
id: De(),
|
|
353
353
|
value: e,
|
|
354
354
|
equals: V(n, (i, l) => i === l),
|
|
355
355
|
name: t,
|
|
356
356
|
subs: lt()
|
|
357
357
|
};
|
|
358
358
|
}
|
|
359
|
-
function
|
|
359
|
+
function vn(e, t) {
|
|
360
360
|
return {
|
|
361
|
-
id:
|
|
361
|
+
id: De(),
|
|
362
362
|
value: e,
|
|
363
363
|
equals: (r, i) => !1,
|
|
364
364
|
name: t,
|
|
365
365
|
subs: lt()
|
|
366
366
|
};
|
|
367
367
|
}
|
|
368
|
-
function vn(e) {
|
|
369
|
-
return ft(e.subs), hn(e.subs), e.value;
|
|
370
|
-
}
|
|
371
368
|
function $n(e) {
|
|
369
|
+
return ft(e.subs), gn(e.subs), e.value;
|
|
370
|
+
}
|
|
371
|
+
function Dn(e) {
|
|
372
372
|
return ft(e.subs), e.value;
|
|
373
373
|
}
|
|
374
374
|
function pt(e, t) {
|
|
@@ -379,30 +379,30 @@ function pt(e, t) {
|
|
|
379
379
|
n = !0;
|
|
380
380
|
}
|
|
381
381
|
if (n)
|
|
382
|
-
return e.value = t, e.subs.version = e.subs.version + 1 | 0,
|
|
382
|
+
return e.value = t, e.subs.version = e.subs.version + 1 | 0, En(e.subs);
|
|
383
383
|
}
|
|
384
384
|
function xn(e, t) {
|
|
385
385
|
pt(e, t(e.value));
|
|
386
386
|
}
|
|
387
|
-
let An, Cn, On,
|
|
388
|
-
const
|
|
387
|
+
let An, Cn, On, Pn = wn, Rn = kn;
|
|
388
|
+
const Mn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
389
389
|
__proto__: null,
|
|
390
390
|
Core: On,
|
|
391
391
|
Id: An,
|
|
392
392
|
Scheduler: Cn,
|
|
393
|
-
batch:
|
|
394
|
-
get:
|
|
395
|
-
make:
|
|
396
|
-
makeForComputed:
|
|
397
|
-
peek:
|
|
393
|
+
batch: Pn,
|
|
394
|
+
get: $n,
|
|
395
|
+
make: Tn,
|
|
396
|
+
makeForComputed: vn,
|
|
397
|
+
peek: Dn,
|
|
398
398
|
set: pt,
|
|
399
|
-
untrack:
|
|
399
|
+
untrack: Rn,
|
|
400
400
|
update: xn
|
|
401
401
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
402
|
-
function
|
|
403
|
-
let n =
|
|
402
|
+
function ht(e, t) {
|
|
403
|
+
let n = De(), r = {
|
|
404
404
|
contents: void 0
|
|
405
|
-
}, l =
|
|
405
|
+
}, l = un(n, "Effect", () => {
|
|
406
406
|
let g = r.contents;
|
|
407
407
|
g !== void 0 && g(), r.contents = e();
|
|
408
408
|
}, t, void 0), u = L.contents;
|
|
@@ -412,7 +412,7 @@ function Mn(e, t) {
|
|
|
412
412
|
} catch (g) {
|
|
413
413
|
throw L.contents = u, g;
|
|
414
414
|
}
|
|
415
|
-
l.level =
|
|
415
|
+
l.level = st(l);
|
|
416
416
|
let d = {
|
|
417
417
|
contents: !1
|
|
418
418
|
};
|
|
@@ -426,50 +426,54 @@ function Mn(e, t) {
|
|
|
426
426
|
}
|
|
427
427
|
};
|
|
428
428
|
}
|
|
429
|
-
|
|
430
|
-
|
|
429
|
+
function jn(e, t) {
|
|
430
|
+
ht(e, t);
|
|
431
|
+
}
|
|
432
|
+
let Fn, Nn, Ln;
|
|
433
|
+
const Wn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
431
434
|
__proto__: null,
|
|
432
|
-
Core:
|
|
433
|
-
Id:
|
|
434
|
-
Scheduler:
|
|
435
|
-
run:
|
|
435
|
+
Core: Nn,
|
|
436
|
+
Id: Fn,
|
|
437
|
+
Scheduler: Ln,
|
|
438
|
+
run: jn,
|
|
439
|
+
runWithDisposer: ht
|
|
436
440
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
437
441
|
function In(e, t) {
|
|
438
|
-
let n =
|
|
442
|
+
let n = De(), r = {
|
|
439
443
|
contents: void 0
|
|
440
|
-
}, l =
|
|
444
|
+
}, l = ln(() => {
|
|
441
445
|
r.contents.value = e();
|
|
442
|
-
}), u =
|
|
443
|
-
|
|
446
|
+
}), u = A.contents;
|
|
447
|
+
A.contents = l;
|
|
444
448
|
let d = e();
|
|
445
|
-
|
|
446
|
-
let
|
|
449
|
+
A.contents = u;
|
|
450
|
+
let s = {
|
|
447
451
|
id: n,
|
|
448
452
|
value: d,
|
|
449
|
-
equals: (g,
|
|
453
|
+
equals: (g, x) => !1,
|
|
450
454
|
name: t,
|
|
451
455
|
subs: l
|
|
452
456
|
};
|
|
453
|
-
return r.contents =
|
|
457
|
+
return r.contents = s, We(l), s;
|
|
454
458
|
}
|
|
455
459
|
function Gn(e) {
|
|
456
|
-
|
|
460
|
+
Ie(e.subs);
|
|
457
461
|
}
|
|
458
|
-
let zn, Bn,
|
|
459
|
-
const
|
|
462
|
+
let zn, Bn, Hn, Xn;
|
|
463
|
+
const Vn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
460
464
|
__proto__: null,
|
|
461
|
-
Core:
|
|
465
|
+
Core: Hn,
|
|
462
466
|
Id: zn,
|
|
463
|
-
Scheduler:
|
|
467
|
+
Scheduler: Xn,
|
|
464
468
|
Signal: Bn,
|
|
465
469
|
dispose: Gn,
|
|
466
470
|
make: In
|
|
467
471
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
468
|
-
let o =
|
|
472
|
+
let o = Mn, M = Vn, v = Wn;
|
|
469
473
|
function Q(e) {
|
|
470
474
|
return e.replaceAll("&", "&").replaceAll("<", "<").replaceAll(">", ">").replaceAll('"', """).replaceAll("'", "'");
|
|
471
475
|
}
|
|
472
|
-
let
|
|
476
|
+
let Be = [
|
|
473
477
|
"area",
|
|
474
478
|
"base",
|
|
475
479
|
"br",
|
|
@@ -485,30 +489,30 @@ let We = [
|
|
|
485
489
|
"track",
|
|
486
490
|
"wbr"
|
|
487
491
|
];
|
|
488
|
-
function
|
|
489
|
-
return
|
|
492
|
+
function Kn(e) {
|
|
493
|
+
return Be.includes(e);
|
|
490
494
|
}
|
|
491
495
|
let mt = {
|
|
492
496
|
escape: Q,
|
|
493
|
-
voidElements:
|
|
494
|
-
isVoidElement:
|
|
495
|
-
},
|
|
496
|
-
function
|
|
497
|
+
voidElements: Be,
|
|
498
|
+
isVoidElement: Kn
|
|
499
|
+
}, gt = "<!--$-->", St = "<!--/$-->", _t = "<!--#-->", yt = "<!--/#-->", bt = "<!--kl-->", Et = "<!--/kl-->";
|
|
500
|
+
function wt(e) {
|
|
497
501
|
return "<!--k:" + e + "-->";
|
|
498
502
|
}
|
|
499
|
-
let
|
|
500
|
-
signalTextStart:
|
|
501
|
-
signalTextEnd:
|
|
502
|
-
signalFragmentStart:
|
|
503
|
-
signalFragmentEnd:
|
|
504
|
-
keyedListStart:
|
|
505
|
-
keyedListEnd:
|
|
506
|
-
keyedItemStart:
|
|
507
|
-
keyedItemEnd:
|
|
508
|
-
lazyComponentStart:
|
|
509
|
-
lazyComponentEnd:
|
|
503
|
+
let kt = "<!--/k-->", Tt = "<!--lc-->", vt = "<!--/lc-->", Yn = {
|
|
504
|
+
signalTextStart: gt,
|
|
505
|
+
signalTextEnd: St,
|
|
506
|
+
signalFragmentStart: _t,
|
|
507
|
+
signalFragmentEnd: yt,
|
|
508
|
+
keyedListStart: bt,
|
|
509
|
+
keyedListEnd: Et,
|
|
510
|
+
keyedItemStart: wt,
|
|
511
|
+
keyedItemEnd: kt,
|
|
512
|
+
lazyComponentStart: Tt,
|
|
513
|
+
lazyComponentEnd: vt
|
|
510
514
|
};
|
|
511
|
-
function
|
|
515
|
+
function $t(e) {
|
|
512
516
|
let t = e[1], n = e[0], r;
|
|
513
517
|
switch (t.TAG) {
|
|
514
518
|
case "Static":
|
|
@@ -536,19 +540,19 @@ function vt(e) {
|
|
|
536
540
|
}
|
|
537
541
|
return r === "true" ? n : "";
|
|
538
542
|
}
|
|
539
|
-
function
|
|
540
|
-
let t = e.map(
|
|
543
|
+
function Dt(e) {
|
|
544
|
+
let t = e.map($t).filter((n) => n !== "");
|
|
541
545
|
return t.length !== 0 ? " " + t.join(" ") : "";
|
|
542
546
|
}
|
|
543
|
-
let
|
|
544
|
-
renderAttr:
|
|
545
|
-
renderAttrs:
|
|
547
|
+
let qn = {
|
|
548
|
+
renderAttr: $t,
|
|
549
|
+
renderAttrs: Dt
|
|
546
550
|
};
|
|
547
551
|
function q(e) {
|
|
548
552
|
switch (e.TAG) {
|
|
549
553
|
case "Element":
|
|
550
|
-
let t = e.tag, n =
|
|
551
|
-
if (
|
|
554
|
+
let t = e.tag, n = Dt(e.attrs);
|
|
555
|
+
if (Be.includes(t))
|
|
552
556
|
return "<" + t + n + " />";
|
|
553
557
|
let r = e.children.map(q).join("");
|
|
554
558
|
return "<" + t + n + ">" + r + "</" + t + ">";
|
|
@@ -556,38 +560,38 @@ function q(e) {
|
|
|
556
560
|
return Q(e._0);
|
|
557
561
|
case "SignalText":
|
|
558
562
|
let i = o.peek(e._0);
|
|
559
|
-
return
|
|
563
|
+
return gt + Q(i) + St;
|
|
560
564
|
case "Fragment":
|
|
561
565
|
return e._0.map(q).join("");
|
|
562
566
|
case "SignalFragment":
|
|
563
567
|
let u = o.peek(e._0).map(q).join("");
|
|
564
|
-
return
|
|
568
|
+
return _t + u + yt;
|
|
565
569
|
case "LazyComponent":
|
|
566
570
|
let d = e._0();
|
|
567
|
-
return
|
|
571
|
+
return Tt + q(d) + vt;
|
|
568
572
|
case "KeyedList":
|
|
569
|
-
let
|
|
570
|
-
let
|
|
571
|
-
return
|
|
573
|
+
let s = e.renderItem, g = e.keyFn, j = o.peek(e.signal).map((F) => {
|
|
574
|
+
let C = g(F), $ = q(s(F));
|
|
575
|
+
return wt(C) + $ + kt;
|
|
572
576
|
}).join("");
|
|
573
|
-
return
|
|
577
|
+
return bt + j + Et;
|
|
574
578
|
}
|
|
575
579
|
}
|
|
576
580
|
function xt(e, t) {
|
|
577
581
|
return q(e());
|
|
578
582
|
}
|
|
579
|
-
function
|
|
583
|
+
function Un(e, t, n) {
|
|
580
584
|
let r = t !== void 0 ? t : "root", i = e(), l = q(i);
|
|
581
585
|
return "<!--xote-root:" + r + "-->" + l + "<!--/xote-root-->";
|
|
582
586
|
}
|
|
583
587
|
function At(e) {
|
|
584
588
|
return "<script" + (e !== void 0 ? ' nonce="' + Q(e) + '"' : "") + ">window.__XOTE_HYDRATED__=false;<\/script>";
|
|
585
589
|
}
|
|
586
|
-
function
|
|
587
|
-
let d = e !== void 0 ? e : "",
|
|
588
|
-
`),
|
|
589
|
-
let
|
|
590
|
-
return '<script type="module" src="' + Q(
|
|
590
|
+
function Jn(e, t, n, r, i, l, u) {
|
|
591
|
+
let d = e !== void 0 ? e : "", s = t !== void 0 ? t : "", g = n !== void 0 ? n : [], x = r !== void 0 ? r : [], j = i !== void 0 ? i : "", F = xt(u), C = At(l), $ = x.map((I) => '<link rel="stylesheet" href="' + Q(I) + '" />').join(`
|
|
592
|
+
`), B = g.map((I) => {
|
|
593
|
+
let G = l !== void 0 ? ' nonce="' + Q(l) + '"' : "";
|
|
594
|
+
return '<script type="module" src="' + Q(I) + '"' + G + "><\/script>";
|
|
591
595
|
}).join(`
|
|
592
596
|
`);
|
|
593
597
|
return `<!DOCTYPE html>
|
|
@@ -595,29 +599,29 @@ function Un(e, t, n, r, i, l, u) {
|
|
|
595
599
|
<head>
|
|
596
600
|
<meta charset="UTF-8" />
|
|
597
601
|
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
|
598
|
-
` +
|
|
602
|
+
` + $ + `
|
|
599
603
|
` + d + `
|
|
600
604
|
</head>
|
|
601
|
-
<body` + (
|
|
605
|
+
<body` + (s !== "" ? " " + s : "") + `>
|
|
602
606
|
<div id="root">` + F + `</div>
|
|
603
607
|
` + j + `
|
|
604
|
-
` +
|
|
605
|
-
` +
|
|
608
|
+
` + C + `
|
|
609
|
+
` + B + `
|
|
606
610
|
</body>
|
|
607
611
|
</html>`;
|
|
608
612
|
}
|
|
609
|
-
let
|
|
610
|
-
const
|
|
613
|
+
let Qn;
|
|
614
|
+
const Zn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
611
615
|
__proto__: null,
|
|
612
|
-
Attributes:
|
|
613
|
-
Component:
|
|
616
|
+
Attributes: qn,
|
|
617
|
+
Component: Qn,
|
|
614
618
|
Html: mt,
|
|
615
|
-
Markers:
|
|
619
|
+
Markers: Yn,
|
|
616
620
|
generateHydrationScript: At,
|
|
617
|
-
renderDocument:
|
|
621
|
+
renderDocument: Jn,
|
|
618
622
|
renderNodeToString: q,
|
|
619
623
|
renderToString: xt,
|
|
620
|
-
renderToStringWithRoot:
|
|
624
|
+
renderToStringWithRoot: Un
|
|
621
625
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
622
626
|
function Ct(e, t) {
|
|
623
627
|
let n = e.length, r = new Array(n), i = 0;
|
|
@@ -627,7 +631,7 @@ function Ct(e, t) {
|
|
|
627
631
|
}
|
|
628
632
|
return r.length = i, r;
|
|
629
633
|
}
|
|
630
|
-
function
|
|
634
|
+
function er(e, t) {
|
|
631
635
|
let n = 0;
|
|
632
636
|
for (; ; ) {
|
|
633
637
|
let r = n;
|
|
@@ -651,7 +655,7 @@ function Ot(e) {
|
|
|
651
655
|
};
|
|
652
656
|
});
|
|
653
657
|
}
|
|
654
|
-
function
|
|
658
|
+
function Pt(e, t) {
|
|
655
659
|
let n = t.split("/").filter((l) => l !== "");
|
|
656
660
|
if (e.length !== n.length)
|
|
657
661
|
return "NoMatch";
|
|
@@ -665,18 +669,18 @@ function Dt(e, t) {
|
|
|
665
669
|
} : "NoMatch";
|
|
666
670
|
}
|
|
667
671
|
function He(e, t) {
|
|
668
|
-
return
|
|
672
|
+
return Pt(Ot(e), t);
|
|
669
673
|
}
|
|
670
|
-
const
|
|
674
|
+
const tr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
671
675
|
__proto__: null,
|
|
672
676
|
match: He,
|
|
673
|
-
matchPath:
|
|
677
|
+
matchPath: Pt,
|
|
674
678
|
parsePattern: Ot
|
|
675
679
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
676
680
|
function Xe(e, t) {
|
|
677
681
|
delete e[t];
|
|
678
682
|
}
|
|
679
|
-
let
|
|
683
|
+
let Rt = "http://www.w3.org/2000/svg", Mt = [
|
|
680
684
|
"svg",
|
|
681
685
|
"path",
|
|
682
686
|
"circle",
|
|
@@ -714,14 +718,14 @@ let Pt = "http://www.w3.org/2000/svg", Rt = [
|
|
|
714
718
|
"desc",
|
|
715
719
|
"title",
|
|
716
720
|
"metadata"
|
|
717
|
-
],
|
|
718
|
-
|
|
719
|
-
|
|
721
|
+
], Ae = {};
|
|
722
|
+
Mt.forEach((e) => {
|
|
723
|
+
Ae[e] = !0;
|
|
720
724
|
});
|
|
721
|
-
function
|
|
722
|
-
return
|
|
725
|
+
function nr(e) {
|
|
726
|
+
return ze(Ae[e]);
|
|
723
727
|
}
|
|
724
|
-
function
|
|
728
|
+
function ce(e, t, n) {
|
|
725
729
|
switch (t) {
|
|
726
730
|
case "checked":
|
|
727
731
|
e.checked = n === "true";
|
|
@@ -746,11 +750,11 @@ function se(e, t, n) {
|
|
|
746
750
|
n === "true" ? e.setAttribute(t, "") : e.removeAttribute(t);
|
|
747
751
|
}
|
|
748
752
|
let pe = {
|
|
749
|
-
setAttrOrProp:
|
|
753
|
+
setAttrOrProp: ce
|
|
750
754
|
}, ke = {
|
|
751
755
|
contents: void 0
|
|
752
756
|
};
|
|
753
|
-
function
|
|
757
|
+
function rr() {
|
|
754
758
|
return {
|
|
755
759
|
disposers: [],
|
|
756
760
|
computeds: []
|
|
@@ -765,25 +769,25 @@ function ue(e, t) {
|
|
|
765
769
|
function oe(e, t) {
|
|
766
770
|
e.disposers.push(t);
|
|
767
771
|
}
|
|
768
|
-
function
|
|
772
|
+
function jt(e) {
|
|
769
773
|
e.disposers.forEach((t) => t.dispose()), e.computeds.forEach((t) => M.dispose(t));
|
|
770
774
|
}
|
|
771
775
|
function de(e, t) {
|
|
772
776
|
e.__xote_owner__ = t;
|
|
773
777
|
}
|
|
774
|
-
function
|
|
775
|
-
return
|
|
778
|
+
function Ft(e) {
|
|
779
|
+
return Ge(e.__xote_owner__);
|
|
776
780
|
}
|
|
777
|
-
let
|
|
781
|
+
let c = {
|
|
778
782
|
currentOwner: ke,
|
|
779
|
-
createOwner:
|
|
783
|
+
createOwner: rr,
|
|
780
784
|
runWithOwner: ue,
|
|
781
785
|
addDisposer: oe,
|
|
782
|
-
disposeOwner:
|
|
786
|
+
disposeOwner: jt,
|
|
783
787
|
setOwner: de,
|
|
784
|
-
getOwner:
|
|
788
|
+
getOwner: Ft
|
|
785
789
|
};
|
|
786
|
-
function
|
|
790
|
+
function Nt(e, t) {
|
|
787
791
|
return [
|
|
788
792
|
e,
|
|
789
793
|
{
|
|
@@ -792,7 +796,7 @@ function Ft(e, t) {
|
|
|
792
796
|
}
|
|
793
797
|
];
|
|
794
798
|
}
|
|
795
|
-
function
|
|
799
|
+
function Lt(e, t) {
|
|
796
800
|
return [
|
|
797
801
|
e,
|
|
798
802
|
{
|
|
@@ -801,7 +805,7 @@ function Nt(e, t) {
|
|
|
801
805
|
}
|
|
802
806
|
];
|
|
803
807
|
}
|
|
804
|
-
function
|
|
808
|
+
function Wt(e, t) {
|
|
805
809
|
return [
|
|
806
810
|
e,
|
|
807
811
|
{
|
|
@@ -810,19 +814,19 @@ function Lt(e, t) {
|
|
|
810
814
|
}
|
|
811
815
|
];
|
|
812
816
|
}
|
|
813
|
-
let
|
|
814
|
-
$$static:
|
|
815
|
-
signal:
|
|
816
|
-
computed:
|
|
817
|
+
let lr = {
|
|
818
|
+
$$static: Nt,
|
|
819
|
+
signal: Lt,
|
|
820
|
+
computed: Wt
|
|
817
821
|
};
|
|
818
822
|
function fe(e) {
|
|
819
|
-
let t =
|
|
820
|
-
t !== void 0 &&
|
|
823
|
+
let t = Ft(e);
|
|
824
|
+
t !== void 0 && jt(t), Array.from(e.childNodes || []).forEach(fe);
|
|
821
825
|
}
|
|
822
826
|
function X(e) {
|
|
823
827
|
switch (e.TAG) {
|
|
824
828
|
case "Element":
|
|
825
|
-
let t = e.children, n = e.events, r = e.attrs, i = e.tag, l =
|
|
829
|
+
let t = e.children, n = e.events, r = e.attrs, i = e.tag, l = ze(Ae[i]) ? document.createElementNS(Rt, i) : document.createElement(i), u = {
|
|
826
830
|
disposers: [],
|
|
827
831
|
computeds: []
|
|
828
832
|
};
|
|
@@ -831,17 +835,17 @@ function X(e) {
|
|
|
831
835
|
let p = a[1], T = a[0];
|
|
832
836
|
switch (p.TAG) {
|
|
833
837
|
case "Static":
|
|
834
|
-
return
|
|
838
|
+
return ce(l, T, p._0);
|
|
835
839
|
case "SignalValue":
|
|
836
|
-
let
|
|
837
|
-
|
|
838
|
-
let R =
|
|
839
|
-
|
|
840
|
+
let D = p._0;
|
|
841
|
+
ce(l, T, o.peek(D));
|
|
842
|
+
let R = v.runWithDisposer(() => {
|
|
843
|
+
ce(l, T, o.get(D));
|
|
840
844
|
}, void 0);
|
|
841
845
|
return oe(u, R);
|
|
842
846
|
case "Compute":
|
|
843
|
-
let
|
|
844
|
-
|
|
847
|
+
let h = p._0, _ = v.runWithDisposer(() => {
|
|
848
|
+
ce(l, T, h());
|
|
845
849
|
}, void 0);
|
|
846
850
|
return oe(u, _);
|
|
847
851
|
}
|
|
@@ -855,45 +859,45 @@ function X(e) {
|
|
|
855
859
|
case "Text":
|
|
856
860
|
return document.createTextNode(e._0);
|
|
857
861
|
case "SignalText":
|
|
858
|
-
let d = e._0,
|
|
862
|
+
let d = e._0, s = document.createTextNode(o.peek(d)), g = {
|
|
859
863
|
disposers: [],
|
|
860
864
|
computeds: []
|
|
861
865
|
};
|
|
862
|
-
return de(
|
|
863
|
-
let a =
|
|
864
|
-
|
|
866
|
+
return de(s, g), ue(g, () => {
|
|
867
|
+
let a = v.runWithDisposer(() => {
|
|
868
|
+
s.textContent = o.get(d);
|
|
865
869
|
}, void 0);
|
|
866
870
|
oe(g, a);
|
|
867
|
-
}),
|
|
871
|
+
}), s;
|
|
868
872
|
case "Fragment":
|
|
869
|
-
let
|
|
873
|
+
let x = document.createDocumentFragment();
|
|
870
874
|
return e._0.forEach((a) => {
|
|
871
875
|
let p = X(a);
|
|
872
|
-
|
|
873
|
-
}),
|
|
876
|
+
x.appendChild(p);
|
|
877
|
+
}), x;
|
|
874
878
|
case "SignalFragment":
|
|
875
879
|
let j = e._0, F = {
|
|
876
880
|
disposers: [],
|
|
877
881
|
computeds: []
|
|
878
|
-
},
|
|
879
|
-
return
|
|
880
|
-
let a =
|
|
882
|
+
}, C = document.createElement("div");
|
|
883
|
+
return C.setAttribute("style", "display: contents"), de(C, F), ue(F, () => {
|
|
884
|
+
let a = v.runWithDisposer(() => {
|
|
881
885
|
let p = o.get(j);
|
|
882
|
-
Array.from(
|
|
883
|
-
let R = X(
|
|
884
|
-
|
|
886
|
+
Array.from(C.childNodes || []).forEach(fe), C.innerHTML = "", p.forEach((D) => {
|
|
887
|
+
let R = X(D);
|
|
888
|
+
C.appendChild(R);
|
|
885
889
|
});
|
|
886
890
|
}, void 0);
|
|
887
891
|
oe(F, a);
|
|
888
|
-
}),
|
|
892
|
+
}), C;
|
|
889
893
|
case "LazyComponent":
|
|
890
|
-
let
|
|
894
|
+
let $ = {
|
|
891
895
|
disposers: [],
|
|
892
896
|
computeds: []
|
|
893
|
-
},
|
|
894
|
-
return de(
|
|
897
|
+
}, B = ue($, e._0), I = X(B);
|
|
898
|
+
return de(I, $), I;
|
|
895
899
|
case "KeyedList":
|
|
896
|
-
let
|
|
900
|
+
let G = e.renderItem, O = e.keyFn, H = e.signal, le = {
|
|
897
901
|
disposers: [],
|
|
898
902
|
computeds: []
|
|
899
903
|
}, k = document.createComment(" keyed-list-start "), y = document.createComment(" keyed-list-end ");
|
|
@@ -903,32 +907,32 @@ function X(e) {
|
|
|
903
907
|
if (a == null)
|
|
904
908
|
return;
|
|
905
909
|
let p = o.get(H), T = {};
|
|
906
|
-
p.forEach((
|
|
907
|
-
T[
|
|
910
|
+
p.forEach((m) => {
|
|
911
|
+
T[O(m)] = m;
|
|
908
912
|
});
|
|
909
|
-
let
|
|
910
|
-
Object.keys(f).forEach((
|
|
911
|
-
if (T[
|
|
912
|
-
|
|
913
|
+
let D = [];
|
|
914
|
+
Object.keys(f).forEach((m) => {
|
|
915
|
+
if (T[m] === void 0) {
|
|
916
|
+
D.push(m);
|
|
913
917
|
return;
|
|
914
918
|
}
|
|
915
|
-
}),
|
|
916
|
-
let w = f[
|
|
919
|
+
}), D.forEach((m) => {
|
|
920
|
+
let w = f[m];
|
|
917
921
|
if (w !== void 0) {
|
|
918
|
-
fe(w.element), w.element.remove(), Xe(f,
|
|
922
|
+
fe(w.element), w.element.remove(), Xe(f, m);
|
|
919
923
|
return;
|
|
920
924
|
}
|
|
921
925
|
});
|
|
922
|
-
let R = [],
|
|
923
|
-
p.forEach((
|
|
924
|
-
let w =
|
|
926
|
+
let R = [], h = {};
|
|
927
|
+
p.forEach((m) => {
|
|
928
|
+
let w = O(m), ie = f[w];
|
|
925
929
|
if (ie !== void 0) {
|
|
926
|
-
if (ie.item !==
|
|
927
|
-
|
|
928
|
-
let Ee =
|
|
930
|
+
if (ie.item !== m) {
|
|
931
|
+
h[w] = !0;
|
|
932
|
+
let Ee = G(m), rn = X(Ee), Qe = {
|
|
929
933
|
key: w,
|
|
930
|
-
item:
|
|
931
|
-
element:
|
|
934
|
+
item: m,
|
|
935
|
+
element: rn
|
|
932
936
|
};
|
|
933
937
|
R.push(Qe), f[w] = Qe;
|
|
934
938
|
return;
|
|
@@ -936,9 +940,9 @@ function X(e) {
|
|
|
936
940
|
R.push(ie);
|
|
937
941
|
return;
|
|
938
942
|
}
|
|
939
|
-
let ye =
|
|
943
|
+
let ye = G(m), Re = X(ye), be = {
|
|
940
944
|
key: w,
|
|
941
|
-
item:
|
|
945
|
+
item: m,
|
|
942
946
|
element: Re
|
|
943
947
|
};
|
|
944
948
|
R.push(be), f[w] = be;
|
|
@@ -946,32 +950,32 @@ function X(e) {
|
|
|
946
950
|
let _ = {
|
|
947
951
|
contents: k.nextSibling
|
|
948
952
|
};
|
|
949
|
-
R.forEach((
|
|
953
|
+
R.forEach((m) => {
|
|
950
954
|
let w = _.contents;
|
|
951
955
|
if (w == null) {
|
|
952
|
-
a.insertBefore(
|
|
956
|
+
a.insertBefore(m.element, y);
|
|
953
957
|
return;
|
|
954
958
|
}
|
|
955
959
|
if (w === y) {
|
|
956
|
-
a.insertBefore(
|
|
960
|
+
a.insertBefore(m.element, y);
|
|
957
961
|
return;
|
|
958
962
|
}
|
|
959
|
-
if (w ===
|
|
963
|
+
if (w === m.element) {
|
|
960
964
|
_.contents = w.nextSibling;
|
|
961
965
|
return;
|
|
962
966
|
}
|
|
963
|
-
V(m
|
|
967
|
+
V(h[m.key], !1) ? (fe(w), a.replaceChild(m.element, w), _.contents = m.element.nextSibling) : (a.insertBefore(m.element, w), _.contents = m.element.nextSibling);
|
|
964
968
|
});
|
|
965
969
|
}, E = document.createDocumentFragment();
|
|
966
970
|
return E.appendChild(k), o.peek(H).forEach((a) => {
|
|
967
|
-
let p =
|
|
971
|
+
let p = O(a), T = G(a), D = X(T), R = {
|
|
968
972
|
key: p,
|
|
969
973
|
item: a,
|
|
970
|
-
element:
|
|
974
|
+
element: D
|
|
971
975
|
};
|
|
972
|
-
f[p] = R, E.appendChild(
|
|
976
|
+
f[p] = R, E.appendChild(D);
|
|
973
977
|
}), E.appendChild(y), ue(le, () => {
|
|
974
|
-
let a =
|
|
978
|
+
let a = v.runWithDisposer(() => {
|
|
975
979
|
b();
|
|
976
980
|
}, void 0);
|
|
977
981
|
oe(le, a);
|
|
@@ -982,37 +986,37 @@ let U = {
|
|
|
982
986
|
disposeElement: fe,
|
|
983
987
|
render: X
|
|
984
988
|
};
|
|
985
|
-
function
|
|
989
|
+
function ir(e) {
|
|
986
990
|
return {
|
|
987
991
|
TAG: "Text",
|
|
988
992
|
_0: e
|
|
989
993
|
};
|
|
990
994
|
}
|
|
991
|
-
function
|
|
995
|
+
function ur(e) {
|
|
992
996
|
return {
|
|
993
997
|
TAG: "SignalText",
|
|
994
998
|
_0: M.make(e, void 0)
|
|
995
999
|
};
|
|
996
1000
|
}
|
|
997
|
-
function
|
|
1001
|
+
function or(e) {
|
|
998
1002
|
return {
|
|
999
1003
|
TAG: "SignalText",
|
|
1000
1004
|
_0: M.make(e, void 0)
|
|
1001
1005
|
};
|
|
1002
1006
|
}
|
|
1003
|
-
function
|
|
1007
|
+
function dr(e) {
|
|
1004
1008
|
return {
|
|
1005
1009
|
TAG: "SignalText",
|
|
1006
1010
|
_0: M.make(() => e().toString(), void 0)
|
|
1007
1011
|
};
|
|
1008
1012
|
}
|
|
1009
|
-
function
|
|
1013
|
+
function ar(e) {
|
|
1010
1014
|
return {
|
|
1011
1015
|
TAG: "SignalText",
|
|
1012
1016
|
_0: M.make(() => e().toString(), void 0)
|
|
1013
1017
|
};
|
|
1014
1018
|
}
|
|
1015
|
-
function
|
|
1019
|
+
function sr(e) {
|
|
1016
1020
|
return {
|
|
1017
1021
|
TAG: "Text",
|
|
1018
1022
|
_0: e.toString()
|
|
@@ -1024,7 +1028,7 @@ function cr(e) {
|
|
|
1024
1028
|
_0: e.toString()
|
|
1025
1029
|
};
|
|
1026
1030
|
}
|
|
1027
|
-
function
|
|
1031
|
+
function fr(e) {
|
|
1028
1032
|
return {
|
|
1029
1033
|
TAG: "Fragment",
|
|
1030
1034
|
_0: e
|
|
@@ -1036,13 +1040,13 @@ function Ve(e) {
|
|
|
1036
1040
|
_0: e
|
|
1037
1041
|
};
|
|
1038
1042
|
}
|
|
1039
|
-
function
|
|
1043
|
+
function pr(e, t) {
|
|
1040
1044
|
return {
|
|
1041
1045
|
TAG: "SignalFragment",
|
|
1042
1046
|
_0: M.make(() => o.get(e).map(t), void 0)
|
|
1043
1047
|
};
|
|
1044
1048
|
}
|
|
1045
|
-
function
|
|
1049
|
+
function hr(e, t, n) {
|
|
1046
1050
|
return {
|
|
1047
1051
|
TAG: "KeyedList",
|
|
1048
1052
|
signal: e,
|
|
@@ -1050,8 +1054,8 @@ function pr(e, t, n) {
|
|
|
1050
1054
|
renderItem: n
|
|
1051
1055
|
};
|
|
1052
1056
|
}
|
|
1053
|
-
function
|
|
1054
|
-
let l = t !== void 0 ? t : [].map((
|
|
1057
|
+
function z(e, t, n, r, i) {
|
|
1058
|
+
let l = t !== void 0 ? t : [].map((s) => s), u = n !== void 0 ? n : [].map((s) => s), d = r !== void 0 ? r : [].map((s) => s);
|
|
1055
1059
|
return {
|
|
1056
1060
|
TAG: "Element",
|
|
1057
1061
|
tag: e,
|
|
@@ -1061,39 +1065,39 @@ function B(e, t, n, r, i) {
|
|
|
1061
1065
|
};
|
|
1062
1066
|
}
|
|
1063
1067
|
function mr(e, t, n, r) {
|
|
1064
|
-
return
|
|
1065
|
-
}
|
|
1066
|
-
function hr(e, t, n, r) {
|
|
1067
|
-
return B("span", e, t, n);
|
|
1068
|
+
return z("div", e, t, n);
|
|
1068
1069
|
}
|
|
1069
1070
|
function gr(e, t, n, r) {
|
|
1070
|
-
return
|
|
1071
|
+
return z("span", e, t, n);
|
|
1071
1072
|
}
|
|
1072
|
-
function Sr(e, t, n) {
|
|
1073
|
-
return
|
|
1073
|
+
function Sr(e, t, n, r) {
|
|
1074
|
+
return z("button", e, t, n);
|
|
1074
1075
|
}
|
|
1075
|
-
function _r(e, t, n
|
|
1076
|
-
return
|
|
1076
|
+
function _r(e, t, n) {
|
|
1077
|
+
return z("input", e, t, void 0);
|
|
1077
1078
|
}
|
|
1078
1079
|
function yr(e, t, n, r) {
|
|
1079
|
-
return
|
|
1080
|
+
return z("h1", e, t, n);
|
|
1080
1081
|
}
|
|
1081
1082
|
function br(e, t, n, r) {
|
|
1082
|
-
return
|
|
1083
|
+
return z("h2", e, t, n);
|
|
1083
1084
|
}
|
|
1084
1085
|
function Er(e, t, n, r) {
|
|
1085
|
-
return
|
|
1086
|
+
return z("h3", e, t, n);
|
|
1086
1087
|
}
|
|
1087
1088
|
function wr(e, t, n, r) {
|
|
1088
|
-
return
|
|
1089
|
+
return z("p", e, t, n);
|
|
1089
1090
|
}
|
|
1090
1091
|
function kr(e, t, n, r) {
|
|
1091
|
-
return
|
|
1092
|
+
return z("ul", e, t, n);
|
|
1093
|
+
}
|
|
1094
|
+
function Tr(e, t, n, r) {
|
|
1095
|
+
return z("li", e, t, n);
|
|
1092
1096
|
}
|
|
1093
1097
|
function Ke(e, t, n, r) {
|
|
1094
|
-
return
|
|
1098
|
+
return z("a", e, t, n);
|
|
1095
1099
|
}
|
|
1096
|
-
function
|
|
1100
|
+
function vr() {
|
|
1097
1101
|
return {
|
|
1098
1102
|
TAG: "Text",
|
|
1099
1103
|
_0: ""
|
|
@@ -1103,7 +1107,7 @@ function It(e, t) {
|
|
|
1103
1107
|
let n = X(e);
|
|
1104
1108
|
t.appendChild(n);
|
|
1105
1109
|
}
|
|
1106
|
-
function
|
|
1110
|
+
function $r(e, t) {
|
|
1107
1111
|
let n = document.getElementById(t);
|
|
1108
1112
|
if (n == null) {
|
|
1109
1113
|
console.error("Container element not found: " + t);
|
|
@@ -1111,51 +1115,51 @@ function vr(e, t) {
|
|
|
1111
1115
|
} else
|
|
1112
1116
|
return It(e, n);
|
|
1113
1117
|
}
|
|
1114
|
-
let
|
|
1118
|
+
let Dr = Ae, he = Nt, Fe = Lt, Gt = Wt;
|
|
1115
1119
|
const xr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
1116
1120
|
__proto__: null,
|
|
1117
|
-
$$null:
|
|
1118
|
-
Attributes:
|
|
1121
|
+
$$null: vr,
|
|
1122
|
+
Attributes: lr,
|
|
1119
1123
|
DOM: pe,
|
|
1120
|
-
Reactivity:
|
|
1124
|
+
Reactivity: c,
|
|
1121
1125
|
Render: U,
|
|
1122
1126
|
a: Ke,
|
|
1123
|
-
attr:
|
|
1124
|
-
button:
|
|
1127
|
+
attr: he,
|
|
1128
|
+
button: Sr,
|
|
1125
1129
|
computedAttr: Gt,
|
|
1126
1130
|
div: mr,
|
|
1127
|
-
element:
|
|
1131
|
+
element: z,
|
|
1128
1132
|
float: cr,
|
|
1129
|
-
fragment:
|
|
1130
|
-
h1:
|
|
1131
|
-
h2:
|
|
1132
|
-
h3:
|
|
1133
|
-
input:
|
|
1134
|
-
int:
|
|
1135
|
-
isSvgTag:
|
|
1136
|
-
keyedList:
|
|
1137
|
-
li:
|
|
1138
|
-
list:
|
|
1133
|
+
fragment: fr,
|
|
1134
|
+
h1: yr,
|
|
1135
|
+
h2: br,
|
|
1136
|
+
h3: Er,
|
|
1137
|
+
input: _r,
|
|
1138
|
+
int: sr,
|
|
1139
|
+
isSvgTag: nr,
|
|
1140
|
+
keyedList: hr,
|
|
1141
|
+
li: Tr,
|
|
1142
|
+
list: pr,
|
|
1139
1143
|
mount: It,
|
|
1140
|
-
mountById:
|
|
1141
|
-
p:
|
|
1142
|
-
reactiveFloat:
|
|
1143
|
-
reactiveInt:
|
|
1144
|
-
reactiveString:
|
|
1144
|
+
mountById: $r,
|
|
1145
|
+
p: wr,
|
|
1146
|
+
reactiveFloat: ar,
|
|
1147
|
+
reactiveInt: dr,
|
|
1148
|
+
reactiveString: or,
|
|
1145
1149
|
signalAttr: Fe,
|
|
1146
1150
|
signalFragment: Ve,
|
|
1147
|
-
span:
|
|
1148
|
-
svgNamespace:
|
|
1149
|
-
svgTagSet:
|
|
1150
|
-
svgTags:
|
|
1151
|
-
text:
|
|
1152
|
-
textSignal:
|
|
1153
|
-
ul:
|
|
1151
|
+
span: gr,
|
|
1152
|
+
svgNamespace: Rt,
|
|
1153
|
+
svgTagSet: Dr,
|
|
1154
|
+
svgTags: Mt,
|
|
1155
|
+
text: ir,
|
|
1156
|
+
textSignal: ur,
|
|
1157
|
+
ul: kr
|
|
1154
1158
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
1155
1159
|
function Ar() {
|
|
1156
1160
|
return Symbol.for("xote.router.state");
|
|
1157
1161
|
}
|
|
1158
|
-
function
|
|
1162
|
+
function W() {
|
|
1159
1163
|
let e = globalThis[Symbol.for("xote.router.state")];
|
|
1160
1164
|
if (e !== void 0)
|
|
1161
1165
|
return e;
|
|
@@ -1174,13 +1178,13 @@ function I() {
|
|
|
1174
1178
|
return globalThis[Symbol.for("xote.router.state")] = t, t;
|
|
1175
1179
|
}
|
|
1176
1180
|
function Cr() {
|
|
1177
|
-
return
|
|
1181
|
+
return W().location;
|
|
1178
1182
|
}
|
|
1179
1183
|
function Or() {
|
|
1180
|
-
return
|
|
1184
|
+
return W().basePath;
|
|
1181
1185
|
}
|
|
1182
1186
|
function ne(e) {
|
|
1183
|
-
if (!
|
|
1187
|
+
if (!W().initialized)
|
|
1184
1188
|
return console.warn(
|
|
1185
1189
|
"[Xote Router] " + e + " called before Router.init(). Make sure to call Router.init() at your app entry point. This may cause incorrect routing behavior."
|
|
1186
1190
|
);
|
|
@@ -1192,11 +1196,11 @@ function Ye(e) {
|
|
|
1192
1196
|
return t.endsWith("/") ? t.slice(0, t.length - 1 | 0) : t;
|
|
1193
1197
|
}
|
|
1194
1198
|
function zt(e) {
|
|
1195
|
-
let t =
|
|
1199
|
+
let t = W().basePath.contents;
|
|
1196
1200
|
return t === "/" ? e : e === t ? "/" : e.startsWith(t + "/") ? e.slice(t.length) : e;
|
|
1197
1201
|
}
|
|
1198
1202
|
function ge(e) {
|
|
1199
|
-
let t =
|
|
1203
|
+
let t = W().basePath.contents;
|
|
1200
1204
|
return t === "/" ? e : e === "/" ? t : t + e;
|
|
1201
1205
|
}
|
|
1202
1206
|
function Bt() {
|
|
@@ -1206,16 +1210,16 @@ function Bt() {
|
|
|
1206
1210
|
t
|
|
1207
1211
|
];
|
|
1208
1212
|
}
|
|
1209
|
-
function
|
|
1213
|
+
function Ce(e, t) {
|
|
1210
1214
|
window.scrollTo(e, t);
|
|
1211
1215
|
}
|
|
1212
|
-
function
|
|
1216
|
+
function Ht(e, t) {
|
|
1213
1217
|
return { scrollX: e, scrollY: t };
|
|
1214
1218
|
}
|
|
1215
1219
|
function qe() {
|
|
1216
1220
|
return {};
|
|
1217
1221
|
}
|
|
1218
|
-
function
|
|
1222
|
+
function Xt(e) {
|
|
1219
1223
|
let t = e && e.scrollX, n = e && e.scrollY;
|
|
1220
1224
|
if (t != null && n != null)
|
|
1221
1225
|
return [
|
|
@@ -1223,8 +1227,8 @@ function Ht(e) {
|
|
|
1223
1227
|
n
|
|
1224
1228
|
];
|
|
1225
1229
|
}
|
|
1226
|
-
function
|
|
1227
|
-
let e = Bt(), t =
|
|
1230
|
+
function Vt() {
|
|
1231
|
+
let e = Bt(), t = Ht(e[0], e[1]), n = window.location.href;
|
|
1228
1232
|
window.history.replaceState(t, "", n);
|
|
1229
1233
|
}
|
|
1230
1234
|
function Ne() {
|
|
@@ -1235,58 +1239,58 @@ function Ne() {
|
|
|
1235
1239
|
hash: window.location.hash
|
|
1236
1240
|
};
|
|
1237
1241
|
}
|
|
1238
|
-
function
|
|
1239
|
-
let n = e !== void 0 ? e : "/", r =
|
|
1242
|
+
function Pr(e, t) {
|
|
1243
|
+
let n = e !== void 0 ? e : "/", r = W(), i = Ye(n);
|
|
1240
1244
|
if (r.basePath.contents = i, o.set(r.location, Ne()), r.initialized)
|
|
1241
1245
|
return;
|
|
1242
1246
|
let l = (u) => {
|
|
1243
|
-
o.set(
|
|
1247
|
+
o.set(W().location, Ne());
|
|
1244
1248
|
let d = window["history.state"];
|
|
1245
1249
|
if (d == null)
|
|
1246
1250
|
return;
|
|
1247
|
-
let
|
|
1248
|
-
if (
|
|
1249
|
-
return
|
|
1251
|
+
let s = Xt(d);
|
|
1252
|
+
if (s !== void 0)
|
|
1253
|
+
return Ce(s[0], s[1]);
|
|
1250
1254
|
};
|
|
1251
1255
|
r.popStateHandler = l, window.addEventListener("popstate", l), r.initialized = !0;
|
|
1252
1256
|
}
|
|
1253
|
-
function
|
|
1254
|
-
let l = e !== void 0 ? e : "/", u = t !== void 0 ? t : "/", d = n !== void 0 ? n : "",
|
|
1255
|
-
g.basePath.contents =
|
|
1257
|
+
function Rr(e, t, n, r, i) {
|
|
1258
|
+
let l = e !== void 0 ? e : "/", u = t !== void 0 ? t : "/", d = n !== void 0 ? n : "", s = r !== void 0 ? r : "", g = W(), x = Ye(l);
|
|
1259
|
+
g.basePath.contents = x, o.set(g.location, {
|
|
1256
1260
|
pathname: u,
|
|
1257
1261
|
search: d,
|
|
1258
|
-
hash:
|
|
1262
|
+
hash: s
|
|
1259
1263
|
}), g.initialized = !0;
|
|
1260
1264
|
}
|
|
1261
1265
|
function Ue(e, t, n, r) {
|
|
1262
1266
|
let i = t !== void 0 ? t : "", l = n !== void 0 ? n : "";
|
|
1263
|
-
ne("Router.push()"),
|
|
1267
|
+
ne("Router.push()"), Vt();
|
|
1264
1268
|
let u = {
|
|
1265
1269
|
pathname: e,
|
|
1266
1270
|
search: i,
|
|
1267
1271
|
hash: l
|
|
1268
|
-
},
|
|
1269
|
-
window.history.pushState(qe(), "",
|
|
1272
|
+
}, s = ge(e) + i + l;
|
|
1273
|
+
window.history.pushState(qe(), "", s), o.set(W().location, u), Ce(0, 0);
|
|
1270
1274
|
}
|
|
1271
|
-
function
|
|
1275
|
+
function Mr(e, t, n, r) {
|
|
1272
1276
|
let i = t !== void 0 ? t : "", l = n !== void 0 ? n : "";
|
|
1273
1277
|
ne("Router.replace()");
|
|
1274
1278
|
let u = {
|
|
1275
1279
|
pathname: e,
|
|
1276
1280
|
search: i,
|
|
1277
1281
|
hash: l
|
|
1278
|
-
},
|
|
1279
|
-
window.history.replaceState(qe(), "",
|
|
1282
|
+
}, s = ge(e) + i + l;
|
|
1283
|
+
window.history.replaceState(qe(), "", s), o.set(W().location, u), Ce(0, 0);
|
|
1280
1284
|
}
|
|
1281
|
-
function
|
|
1285
|
+
function jr(e, t) {
|
|
1282
1286
|
return ne("Router.route()"), Ve(M.make(() => {
|
|
1283
|
-
let n = o.get(
|
|
1287
|
+
let n = o.get(W().location), r = He(e, n.pathname);
|
|
1284
1288
|
return typeof r != "object" ? [] : [t(r._0)];
|
|
1285
1289
|
}, void 0));
|
|
1286
1290
|
}
|
|
1287
|
-
function
|
|
1291
|
+
function Fr(e) {
|
|
1288
1292
|
return ne("Router.routes()"), Ve(M.make(() => {
|
|
1289
|
-
let t = o.get(
|
|
1293
|
+
let t = o.get(W().location), n = er(e, (r) => {
|
|
1290
1294
|
let i = He(r.pattern, t.pathname);
|
|
1291
1295
|
if (typeof i == "object")
|
|
1292
1296
|
return r.render(i._0);
|
|
@@ -1294,24 +1298,24 @@ function jr(e) {
|
|
|
1294
1298
|
return n !== void 0 ? [n] : [];
|
|
1295
1299
|
}, void 0));
|
|
1296
1300
|
}
|
|
1297
|
-
function
|
|
1301
|
+
function Nr(e, t, n, r) {
|
|
1298
1302
|
let i = t !== void 0 ? t : [], l = n !== void 0 ? n : [];
|
|
1299
1303
|
ne("Router.link()");
|
|
1300
1304
|
let u = (d) => {
|
|
1301
1305
|
d.preventDefault(), Ue(e, void 0, void 0);
|
|
1302
1306
|
};
|
|
1303
|
-
return Ke(i.concat([
|
|
1307
|
+
return Ke(i.concat([he("href", ge(e))]), [[
|
|
1304
1308
|
"click",
|
|
1305
1309
|
u
|
|
1306
1310
|
]], l);
|
|
1307
1311
|
}
|
|
1308
|
-
function
|
|
1312
|
+
function Kt(e) {
|
|
1309
1313
|
return e && typeof e == "object" && "TAG" in e && (e.TAG === "Static" || e.TAG === "Reactive");
|
|
1310
1314
|
}
|
|
1311
1315
|
function ae(e, t) {
|
|
1312
|
-
return
|
|
1316
|
+
return Kt(t) ? t.TAG === "Reactive" ? Fe(e, t._0) : he(e, t._0) : typeof t == "function" ? Gt(e, t) : typeof t == "object" ? Fe(e, t) : he(e, t);
|
|
1313
1317
|
}
|
|
1314
|
-
function
|
|
1318
|
+
function Yt(e) {
|
|
1315
1319
|
let t = [], n = e.class;
|
|
1316
1320
|
n !== void 0 && t.push(ae("class", S(n)));
|
|
1317
1321
|
let r = e.id;
|
|
@@ -1323,7 +1327,7 @@ function Kt(e) {
|
|
|
1323
1327
|
let u = e["aria-label"];
|
|
1324
1328
|
return u !== void 0 && t.push(ae("aria-label", S(u))), t;
|
|
1325
1329
|
}
|
|
1326
|
-
function
|
|
1330
|
+
function qt(e) {
|
|
1327
1331
|
let t = e.children;
|
|
1328
1332
|
return t !== void 0 ? t.TAG === "Fragment" ? t._0 : [t] : [];
|
|
1329
1333
|
}
|
|
@@ -1335,51 +1339,51 @@ function Te(e) {
|
|
|
1335
1339
|
if (r !== void 0)
|
|
1336
1340
|
return r(n);
|
|
1337
1341
|
};
|
|
1338
|
-
return Ke(
|
|
1342
|
+
return Ke(Yt(e).concat([he("href", ge(e.to))]), [[
|
|
1339
1343
|
"click",
|
|
1340
1344
|
t
|
|
1341
|
-
]],
|
|
1345
|
+
]], qt(e));
|
|
1342
1346
|
}
|
|
1343
1347
|
function rt(e, t, n) {
|
|
1344
1348
|
return Te(e);
|
|
1345
1349
|
}
|
|
1346
|
-
let
|
|
1350
|
+
let Lr = {
|
|
1347
1351
|
ReactiveProp: void 0,
|
|
1348
|
-
isReactiveProp:
|
|
1352
|
+
isReactiveProp: Kt,
|
|
1349
1353
|
convertAttrValue: ae,
|
|
1350
|
-
propsToAttrs:
|
|
1351
|
-
getChildren:
|
|
1354
|
+
propsToAttrs: Yt,
|
|
1355
|
+
getChildren: qt,
|
|
1352
1356
|
make: Te,
|
|
1353
1357
|
jsx: Te,
|
|
1354
1358
|
jsxs: Te,
|
|
1355
1359
|
jsxKeyed: rt,
|
|
1356
1360
|
jsxsKeyed: rt
|
|
1357
|
-
},
|
|
1361
|
+
}, Wr, Ir;
|
|
1358
1362
|
const Gr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
1359
1363
|
__proto__: null,
|
|
1360
|
-
Component:
|
|
1361
|
-
Link:
|
|
1364
|
+
Component: Wr,
|
|
1365
|
+
Link: Lr,
|
|
1362
1366
|
Route: Ir,
|
|
1363
1367
|
addBasePath: ge,
|
|
1364
1368
|
basePath: Or,
|
|
1365
1369
|
emptyHistoryState: qe,
|
|
1366
1370
|
getCurrentLocation: Ne,
|
|
1367
|
-
getGlobalState:
|
|
1368
|
-
getScrollFromState:
|
|
1371
|
+
getGlobalState: W,
|
|
1372
|
+
getScrollFromState: Xt,
|
|
1369
1373
|
getScrollPosition: Bt,
|
|
1370
1374
|
getSymbolKey: Ar,
|
|
1371
|
-
init:
|
|
1372
|
-
initSSR:
|
|
1373
|
-
link:
|
|
1375
|
+
init: Pr,
|
|
1376
|
+
initSSR: Rr,
|
|
1377
|
+
link: Nr,
|
|
1374
1378
|
location: Cr,
|
|
1375
|
-
makeHistoryState:
|
|
1379
|
+
makeHistoryState: Ht,
|
|
1376
1380
|
normalizeBasePath: Ye,
|
|
1377
1381
|
push: Ue,
|
|
1378
|
-
replace:
|
|
1379
|
-
route:
|
|
1380
|
-
routes:
|
|
1381
|
-
saveScrollPosition:
|
|
1382
|
-
scrollTo:
|
|
1382
|
+
replace: Mr,
|
|
1383
|
+
route: jr,
|
|
1384
|
+
routes: Fr,
|
|
1385
|
+
saveScrollPosition: Vt,
|
|
1386
|
+
scrollTo: Ce,
|
|
1383
1387
|
stripBasePath: zt,
|
|
1384
1388
|
warnIfNotInitialized: ne
|
|
1385
1389
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
@@ -1391,92 +1395,92 @@ function Br(e) {
|
|
|
1391
1395
|
if (e === null)
|
|
1392
1396
|
return null;
|
|
1393
1397
|
}
|
|
1394
|
-
function
|
|
1398
|
+
function Hr(e) {
|
|
1395
1399
|
if (typeof e == "string")
|
|
1396
1400
|
return e;
|
|
1397
1401
|
}
|
|
1398
|
-
function
|
|
1402
|
+
function Xr(e) {
|
|
1399
1403
|
if (typeof e == "number")
|
|
1400
1404
|
return e;
|
|
1401
1405
|
}
|
|
1402
|
-
function
|
|
1406
|
+
function Vr(e) {
|
|
1403
1407
|
if (typeof e == "object" && e !== null && !Array.isArray(e))
|
|
1404
1408
|
return e;
|
|
1405
1409
|
}
|
|
1406
|
-
function
|
|
1410
|
+
function Kr(e) {
|
|
1407
1411
|
if (Array.isArray(e))
|
|
1408
1412
|
return e;
|
|
1409
1413
|
}
|
|
1410
1414
|
let re = {
|
|
1411
1415
|
bool: zr,
|
|
1412
1416
|
$$null: Br,
|
|
1413
|
-
string:
|
|
1414
|
-
float:
|
|
1415
|
-
object:
|
|
1416
|
-
array:
|
|
1417
|
-
}, Se = typeof document > "u",
|
|
1418
|
-
function
|
|
1417
|
+
string: Hr,
|
|
1418
|
+
float: Xr,
|
|
1419
|
+
object: Vr,
|
|
1420
|
+
array: Kr
|
|
1421
|
+
}, Se = typeof document > "u", Oe = !Se;
|
|
1422
|
+
function Yr(e) {
|
|
1419
1423
|
if (Se)
|
|
1420
1424
|
return te(e());
|
|
1421
1425
|
}
|
|
1422
|
-
function
|
|
1423
|
-
if (
|
|
1426
|
+
function qr(e) {
|
|
1427
|
+
if (Oe)
|
|
1424
1428
|
return te(e());
|
|
1425
1429
|
}
|
|
1426
|
-
function
|
|
1430
|
+
function Ut(e, t) {
|
|
1427
1431
|
return Se ? e() : t();
|
|
1428
1432
|
}
|
|
1429
|
-
const
|
|
1433
|
+
const Ur = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
1430
1434
|
__proto__: null,
|
|
1431
|
-
isClient:
|
|
1435
|
+
isClient: Oe,
|
|
1432
1436
|
isServer: Se,
|
|
1433
|
-
match:
|
|
1434
|
-
onClient:
|
|
1435
|
-
onServer:
|
|
1437
|
+
match: Ut,
|
|
1438
|
+
onClient: qr,
|
|
1439
|
+
onServer: Yr
|
|
1436
1440
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
1437
|
-
function
|
|
1441
|
+
function Jr(e) {
|
|
1438
1442
|
return e;
|
|
1439
1443
|
}
|
|
1440
|
-
function
|
|
1444
|
+
function Qr(e) {
|
|
1441
1445
|
let t = re.float(e);
|
|
1442
1446
|
if (t !== void 0)
|
|
1443
1447
|
return t | 0;
|
|
1444
1448
|
}
|
|
1445
|
-
let
|
|
1446
|
-
encode:
|
|
1447
|
-
decode:
|
|
1449
|
+
let Zr = {
|
|
1450
|
+
encode: Jr,
|
|
1451
|
+
decode: Qr
|
|
1448
1452
|
};
|
|
1449
|
-
function
|
|
1453
|
+
function el(e) {
|
|
1450
1454
|
return e;
|
|
1451
1455
|
}
|
|
1452
|
-
function
|
|
1456
|
+
function tl(e) {
|
|
1453
1457
|
return re.float(e);
|
|
1454
1458
|
}
|
|
1455
|
-
let
|
|
1456
|
-
encode:
|
|
1457
|
-
decode:
|
|
1459
|
+
let nl = {
|
|
1460
|
+
encode: el,
|
|
1461
|
+
decode: tl
|
|
1458
1462
|
};
|
|
1459
|
-
function
|
|
1463
|
+
function rl(e) {
|
|
1460
1464
|
return e;
|
|
1461
1465
|
}
|
|
1462
|
-
function
|
|
1466
|
+
function ll(e) {
|
|
1463
1467
|
return re.string(e);
|
|
1464
1468
|
}
|
|
1465
|
-
let
|
|
1466
|
-
encode:
|
|
1467
|
-
decode:
|
|
1469
|
+
let il = {
|
|
1470
|
+
encode: rl,
|
|
1471
|
+
decode: ll
|
|
1468
1472
|
};
|
|
1469
|
-
function
|
|
1473
|
+
function ul(e) {
|
|
1470
1474
|
return e;
|
|
1471
1475
|
}
|
|
1472
|
-
function
|
|
1476
|
+
function ol(e) {
|
|
1473
1477
|
return re.bool(e);
|
|
1474
1478
|
}
|
|
1475
|
-
let
|
|
1476
|
-
encode:
|
|
1477
|
-
decode:
|
|
1479
|
+
let dl = {
|
|
1480
|
+
encode: ul,
|
|
1481
|
+
decode: ol
|
|
1478
1482
|
};
|
|
1479
|
-
function
|
|
1483
|
+
function al(e) {
|
|
1480
1484
|
return {
|
|
1481
1485
|
encode: (t) => t.map(e.encode),
|
|
1482
1486
|
decode: (t) => {
|
|
@@ -1489,10 +1493,10 @@ function dl(e) {
|
|
|
1489
1493
|
}
|
|
1490
1494
|
};
|
|
1491
1495
|
}
|
|
1492
|
-
function
|
|
1496
|
+
function sl(e) {
|
|
1493
1497
|
return {
|
|
1494
1498
|
encode: (t) => t !== void 0 ? e.encode(S(t)) : null,
|
|
1495
|
-
decode: (t) =>
|
|
1499
|
+
decode: (t) => ze(re.$$null(t)) ? te(void 0) : fn(e.decode(t), (n) => te(n))
|
|
1496
1500
|
};
|
|
1497
1501
|
}
|
|
1498
1502
|
function cl(e, t) {
|
|
@@ -1514,7 +1518,7 @@ function cl(e, t) {
|
|
|
1514
1518
|
}
|
|
1515
1519
|
};
|
|
1516
1520
|
}
|
|
1517
|
-
function
|
|
1521
|
+
function fl(e, t, n) {
|
|
1518
1522
|
return {
|
|
1519
1523
|
encode: (r) => [
|
|
1520
1524
|
e.encode(r[0]),
|
|
@@ -1525,17 +1529,17 @@ function sl(e, t, n) {
|
|
|
1525
1529
|
let i = Array.isArray(r) ? r : void 0;
|
|
1526
1530
|
if (i === void 0 || i.length !== 3)
|
|
1527
1531
|
return;
|
|
1528
|
-
let l = i[0], u = i[1], d = i[2],
|
|
1529
|
-
if (
|
|
1532
|
+
let l = i[0], u = i[1], d = i[2], s = e.decode(l), g = t.decode(u), x = n.decode(d);
|
|
1533
|
+
if (s !== void 0 && g !== void 0 && x !== void 0)
|
|
1530
1534
|
return [
|
|
1531
|
-
S(
|
|
1535
|
+
S(s),
|
|
1532
1536
|
S(g),
|
|
1533
|
-
S(
|
|
1537
|
+
S(x)
|
|
1534
1538
|
];
|
|
1535
1539
|
}
|
|
1536
1540
|
};
|
|
1537
1541
|
}
|
|
1538
|
-
function
|
|
1542
|
+
function pl(e) {
|
|
1539
1543
|
return {
|
|
1540
1544
|
encode: (t) => {
|
|
1541
1545
|
let n = {};
|
|
@@ -1558,77 +1562,77 @@ function fl(e) {
|
|
|
1558
1562
|
}
|
|
1559
1563
|
};
|
|
1560
1564
|
}
|
|
1561
|
-
function
|
|
1565
|
+
function hl(e, t) {
|
|
1562
1566
|
return {
|
|
1563
1567
|
encode: e,
|
|
1564
1568
|
decode: t
|
|
1565
1569
|
};
|
|
1566
1570
|
}
|
|
1567
1571
|
let ml = {
|
|
1568
|
-
int:
|
|
1569
|
-
float:
|
|
1570
|
-
string:
|
|
1571
|
-
bool:
|
|
1572
|
-
array:
|
|
1573
|
-
option:
|
|
1572
|
+
int: Zr,
|
|
1573
|
+
float: nl,
|
|
1574
|
+
string: il,
|
|
1575
|
+
bool: dl,
|
|
1576
|
+
array: al,
|
|
1577
|
+
option: sl,
|
|
1574
1578
|
tuple2: cl,
|
|
1575
|
-
tuple3:
|
|
1576
|
-
dict:
|
|
1577
|
-
make:
|
|
1578
|
-
},
|
|
1579
|
-
function
|
|
1579
|
+
tuple3: fl,
|
|
1580
|
+
dict: pl,
|
|
1581
|
+
make: hl
|
|
1582
|
+
}, me = {};
|
|
1583
|
+
function Jt(e, t, n) {
|
|
1580
1584
|
if (Se) {
|
|
1581
|
-
|
|
1585
|
+
me[e] = n.encode(o.peek(t));
|
|
1582
1586
|
return;
|
|
1583
1587
|
}
|
|
1584
1588
|
}
|
|
1585
|
-
function
|
|
1586
|
-
Object.keys(
|
|
1587
|
-
Xe(
|
|
1589
|
+
function gl() {
|
|
1590
|
+
Object.keys(me).forEach((e) => {
|
|
1591
|
+
Xe(me, e);
|
|
1588
1592
|
});
|
|
1589
1593
|
}
|
|
1590
|
-
function
|
|
1594
|
+
function Qt(e) {
|
|
1591
1595
|
return e.replaceAll("<\/script>", "<\\/script>").replaceAll("<!--", "<\\!--");
|
|
1592
1596
|
}
|
|
1593
|
-
function
|
|
1594
|
-
let t = V(JSON.stringify(
|
|
1597
|
+
function Sl(e) {
|
|
1598
|
+
let t = V(JSON.stringify(me), "{}"), n = Qt(t);
|
|
1595
1599
|
return "<script" + (e !== void 0 ? ' nonce="' + mt.escape(e) + '"' : "") + ">window.__XOTE_STATE__=" + n + ";<\/script>";
|
|
1596
1600
|
}
|
|
1597
|
-
function
|
|
1598
|
-
return
|
|
1601
|
+
function Zt() {
|
|
1602
|
+
return Oe ? window.__XOTE_STATE__ || {} : {};
|
|
1599
1603
|
}
|
|
1600
|
-
function
|
|
1601
|
-
if (!
|
|
1604
|
+
function en(e, t, n) {
|
|
1605
|
+
if (!Oe)
|
|
1602
1606
|
return;
|
|
1603
|
-
let i =
|
|
1607
|
+
let i = Zt()[e];
|
|
1604
1608
|
if (i === void 0)
|
|
1605
1609
|
return;
|
|
1606
1610
|
let l = n.decode(i);
|
|
1607
1611
|
if (l !== void 0)
|
|
1608
1612
|
return o.set(t, S(l));
|
|
1609
1613
|
}
|
|
1610
|
-
function
|
|
1611
|
-
|
|
1614
|
+
function tn(e, t, n) {
|
|
1615
|
+
Ut(() => Jt(e, t, n), () => en(e, t, n));
|
|
1612
1616
|
}
|
|
1613
|
-
function
|
|
1617
|
+
function _l(e, t, n) {
|
|
1614
1618
|
let r = o.make(t, void 0, void 0);
|
|
1615
|
-
return
|
|
1619
|
+
return tn(e, r, n), r;
|
|
1616
1620
|
}
|
|
1617
|
-
const
|
|
1621
|
+
const yl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
1618
1622
|
__proto__: null,
|
|
1619
1623
|
Codec: ml,
|
|
1620
|
-
clear:
|
|
1621
|
-
escapeForScript:
|
|
1622
|
-
generateScript:
|
|
1623
|
-
getClientState:
|
|
1624
|
-
make:
|
|
1625
|
-
register:
|
|
1626
|
-
registry:
|
|
1627
|
-
restore:
|
|
1628
|
-
sync:
|
|
1624
|
+
clear: gl,
|
|
1625
|
+
escapeForScript: Qt,
|
|
1626
|
+
generateScript: Sl,
|
|
1627
|
+
getClientState: Zt,
|
|
1628
|
+
make: _l,
|
|
1629
|
+
register: Jt,
|
|
1630
|
+
registry: me,
|
|
1631
|
+
restore: en,
|
|
1632
|
+
sync: tn
|
|
1629
1633
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
1630
1634
|
let je = {};
|
|
1631
|
-
function
|
|
1635
|
+
function bl(e) {
|
|
1632
1636
|
let t = je[e];
|
|
1633
1637
|
if (t !== void 0) {
|
|
1634
1638
|
let n = t + 1 | 0;
|
|
@@ -1636,7 +1640,7 @@ function yl(e) {
|
|
|
1636
1640
|
}
|
|
1637
1641
|
return je[e] = 1, e;
|
|
1638
1642
|
}
|
|
1639
|
-
function
|
|
1643
|
+
function El(e) {
|
|
1640
1644
|
return Array.from(e.childNodes || []);
|
|
1641
1645
|
}
|
|
1642
1646
|
function _e(e, t) {
|
|
@@ -1658,18 +1662,18 @@ function Je(e) {
|
|
|
1658
1662
|
if (t != null && t.startsWith("k:"))
|
|
1659
1663
|
return t.slice(2);
|
|
1660
1664
|
}
|
|
1661
|
-
function
|
|
1665
|
+
function se(e) {
|
|
1662
1666
|
return {
|
|
1663
|
-
current:
|
|
1667
|
+
current: Ge(e.firstChild),
|
|
1664
1668
|
parent: e
|
|
1665
1669
|
};
|
|
1666
1670
|
}
|
|
1667
|
-
function
|
|
1671
|
+
function wl(e) {
|
|
1668
1672
|
return e.current;
|
|
1669
1673
|
}
|
|
1670
1674
|
function N(e) {
|
|
1671
1675
|
let t = e.current;
|
|
1672
|
-
return t !== void 0 && (e.current =
|
|
1676
|
+
return t !== void 0 && (e.current = Ge(S(t).nextSibling)), t;
|
|
1673
1677
|
}
|
|
1674
1678
|
function K(e, t) {
|
|
1675
1679
|
return (() => {
|
|
@@ -1700,86 +1704,86 @@ function $e(e, t) {
|
|
|
1700
1704
|
}
|
|
1701
1705
|
})(), n;
|
|
1702
1706
|
}
|
|
1703
|
-
let
|
|
1707
|
+
let kl = {
|
|
1704
1708
|
elementNode: 1,
|
|
1705
1709
|
textNode: 3,
|
|
1706
1710
|
commentNode: 8,
|
|
1707
|
-
getChildNodes:
|
|
1711
|
+
getChildNodes: El,
|
|
1708
1712
|
isMarker: _e,
|
|
1709
1713
|
isMarkerPrefix: Pe,
|
|
1710
1714
|
extractKey: Je,
|
|
1711
|
-
make:
|
|
1712
|
-
peek:
|
|
1715
|
+
make: se,
|
|
1716
|
+
peek: wl,
|
|
1713
1717
|
next: N,
|
|
1714
1718
|
skipUntilMarker: K,
|
|
1715
1719
|
collectUntilMarker: $e
|
|
1716
|
-
},
|
|
1720
|
+
}, Tl = /* @__PURE__ */ bl("Xote__Hydration.HydrationMismatch");
|
|
1717
1721
|
function Le(e) {
|
|
1718
1722
|
console.warn("[Xote Hydration] " + e);
|
|
1719
1723
|
}
|
|
1720
|
-
function
|
|
1724
|
+
function vl(e, t) {
|
|
1721
1725
|
for (; ; ) {
|
|
1722
1726
|
let n = e;
|
|
1723
1727
|
switch (n.TAG) {
|
|
1724
1728
|
case "Element":
|
|
1725
|
-
let r = n.children, i = n.events, l = n.attrs, u =
|
|
1726
|
-
return
|
|
1729
|
+
let r = n.children, i = n.events, l = n.attrs, u = c.createOwner();
|
|
1730
|
+
return c.setOwner(t, u), c.runWithOwner(u, () => {
|
|
1727
1731
|
l.forEach((y) => {
|
|
1728
1732
|
let f = y[1], b = y[0];
|
|
1729
1733
|
switch (f.TAG) {
|
|
1730
1734
|
case "Static":
|
|
1731
1735
|
return;
|
|
1732
1736
|
case "SignalValue":
|
|
1733
|
-
let E = f._0, P =
|
|
1737
|
+
let E = f._0, P = v.runWithDisposer(() => {
|
|
1734
1738
|
pe.setAttrOrProp(t, b, o.get(E));
|
|
1735
1739
|
}, void 0);
|
|
1736
|
-
return
|
|
1740
|
+
return c.addDisposer(u, P);
|
|
1737
1741
|
case "Compute":
|
|
1738
|
-
let a = f._0, p =
|
|
1742
|
+
let a = f._0, p = v.runWithDisposer(() => {
|
|
1739
1743
|
pe.setAttrOrProp(t, b, a());
|
|
1740
1744
|
}, void 0);
|
|
1741
|
-
return
|
|
1745
|
+
return c.addDisposer(u, p);
|
|
1742
1746
|
}
|
|
1743
1747
|
}), i.forEach((y) => {
|
|
1744
1748
|
t.addEventListener(y[0], y[1]);
|
|
1745
1749
|
});
|
|
1746
|
-
let k =
|
|
1750
|
+
let k = se(t);
|
|
1747
1751
|
r.forEach((y) => Z(y, k));
|
|
1748
1752
|
});
|
|
1749
1753
|
case "Text":
|
|
1750
1754
|
return;
|
|
1751
1755
|
case "SignalText":
|
|
1752
|
-
let d = n._0,
|
|
1753
|
-
return
|
|
1754
|
-
let k =
|
|
1756
|
+
let d = n._0, s = c.createOwner();
|
|
1757
|
+
return c.setOwner(t, s), c.runWithOwner(s, () => {
|
|
1758
|
+
let k = v.runWithDisposer(() => {
|
|
1755
1759
|
t.textContent = o.get(d);
|
|
1756
1760
|
}, void 0);
|
|
1757
|
-
|
|
1761
|
+
c.addDisposer(s, k);
|
|
1758
1762
|
});
|
|
1759
1763
|
case "Fragment":
|
|
1760
|
-
let g =
|
|
1764
|
+
let g = se(t);
|
|
1761
1765
|
n._0.forEach((k) => Z(k, g));
|
|
1762
1766
|
return;
|
|
1763
1767
|
case "SignalFragment":
|
|
1764
|
-
let
|
|
1765
|
-
return
|
|
1766
|
-
let k =
|
|
1767
|
-
let y = o.get(
|
|
1768
|
-
Array.from(t.childNodes || []).forEach((b) =>
|
|
1768
|
+
let x = n._0, j = c.createOwner();
|
|
1769
|
+
return c.setOwner(t, j), c.runWithOwner(j, () => {
|
|
1770
|
+
let k = v.runWithDisposer(() => {
|
|
1771
|
+
let y = o.get(x);
|
|
1772
|
+
Array.from(t.childNodes || []).forEach((b) => c.disposeOwner(V(c.getOwner(b), c.createOwner()))), t.innerHTML = "", y.forEach((b) => {
|
|
1769
1773
|
let E = U.render(b);
|
|
1770
1774
|
t.appendChild(E);
|
|
1771
1775
|
});
|
|
1772
1776
|
}, void 0);
|
|
1773
|
-
|
|
1777
|
+
c.addDisposer(j, k);
|
|
1774
1778
|
});
|
|
1775
1779
|
case "LazyComponent":
|
|
1776
|
-
let F =
|
|
1777
|
-
|
|
1780
|
+
let F = c.createOwner(), C = c.runWithOwner(F, n._0);
|
|
1781
|
+
c.setOwner(t, F), e = C;
|
|
1778
1782
|
continue;
|
|
1779
1783
|
case "KeyedList":
|
|
1780
|
-
let
|
|
1781
|
-
|
|
1782
|
-
let
|
|
1784
|
+
let $ = n.renderItem, B = n.keyFn, I = n.signal, G = c.createOwner();
|
|
1785
|
+
c.setOwner(t, G);
|
|
1786
|
+
let O = {}, H = se(t);
|
|
1783
1787
|
return K(H, "kl"), (() => {
|
|
1784
1788
|
for (; ; ) {
|
|
1785
1789
|
let k = H.current;
|
|
@@ -1796,82 +1800,82 @@ function Tl(e, t) {
|
|
|
1796
1800
|
N(H);
|
|
1797
1801
|
let E = $e(H, "/k").find((P) => P.nodeType === 1);
|
|
1798
1802
|
if (E !== void 0) {
|
|
1799
|
-
let P = o.peek(
|
|
1800
|
-
|
|
1803
|
+
let P = o.peek(I), a = V(P.find((p) => B(p) === f), {});
|
|
1804
|
+
O[f] = {
|
|
1801
1805
|
key: f,
|
|
1802
1806
|
item: a,
|
|
1803
1807
|
element: S(E)
|
|
1804
1808
|
};
|
|
1805
1809
|
}
|
|
1806
1810
|
}
|
|
1807
|
-
})(),
|
|
1811
|
+
})(), c.runWithOwner(G, () => {
|
|
1808
1812
|
let k = document.createComment(" keyed-list-start "), y = document.createComment(" keyed-list-end "), f = t.firstChild;
|
|
1809
1813
|
f == null ? t.appendChild(k) : t.insertBefore(k, f), t.appendChild(y);
|
|
1810
1814
|
let b = () => {
|
|
1811
|
-
let P = o.get(
|
|
1812
|
-
P.forEach((
|
|
1813
|
-
a[
|
|
1815
|
+
let P = o.get(I), a = {};
|
|
1816
|
+
P.forEach((h) => {
|
|
1817
|
+
a[B(h)] = h;
|
|
1814
1818
|
});
|
|
1815
1819
|
let p = [];
|
|
1816
|
-
Object.keys(
|
|
1817
|
-
if (a[
|
|
1818
|
-
p.push(
|
|
1820
|
+
Object.keys(O).forEach((h) => {
|
|
1821
|
+
if (a[h] === void 0) {
|
|
1822
|
+
p.push(h);
|
|
1819
1823
|
return;
|
|
1820
1824
|
}
|
|
1821
|
-
}), p.forEach((
|
|
1822
|
-
let _ =
|
|
1825
|
+
}), p.forEach((h) => {
|
|
1826
|
+
let _ = O[h];
|
|
1823
1827
|
if (_ !== void 0) {
|
|
1824
|
-
U.disposeElement(_.element), _.element.remove(), Xe(
|
|
1828
|
+
U.disposeElement(_.element), _.element.remove(), Xe(O, h);
|
|
1825
1829
|
return;
|
|
1826
1830
|
}
|
|
1827
1831
|
});
|
|
1828
|
-
let T = [],
|
|
1829
|
-
P.forEach((
|
|
1830
|
-
let _ =
|
|
1831
|
-
if (
|
|
1832
|
-
if (
|
|
1833
|
-
|
|
1834
|
-
let Re =
|
|
1832
|
+
let T = [], D = {};
|
|
1833
|
+
P.forEach((h) => {
|
|
1834
|
+
let _ = B(h), m = O[_];
|
|
1835
|
+
if (m !== void 0) {
|
|
1836
|
+
if (m.item !== h) {
|
|
1837
|
+
D[_] = !0;
|
|
1838
|
+
let Re = $(h), be = U.render(Re), Ee = {
|
|
1835
1839
|
key: _,
|
|
1836
|
-
item:
|
|
1840
|
+
item: h,
|
|
1837
1841
|
element: be
|
|
1838
1842
|
};
|
|
1839
|
-
T.push(Ee),
|
|
1843
|
+
T.push(Ee), O[_] = Ee;
|
|
1840
1844
|
return;
|
|
1841
1845
|
}
|
|
1842
|
-
T.push(
|
|
1846
|
+
T.push(m);
|
|
1843
1847
|
return;
|
|
1844
1848
|
}
|
|
1845
|
-
let w =
|
|
1849
|
+
let w = $(h), ie = U.render(w), ye = {
|
|
1846
1850
|
key: _,
|
|
1847
|
-
item:
|
|
1851
|
+
item: h,
|
|
1848
1852
|
element: ie
|
|
1849
1853
|
};
|
|
1850
|
-
T.push(ye),
|
|
1854
|
+
T.push(ye), O[_] = ye;
|
|
1851
1855
|
});
|
|
1852
1856
|
let R = {
|
|
1853
1857
|
contents: k.nextSibling
|
|
1854
1858
|
};
|
|
1855
|
-
T.forEach((
|
|
1859
|
+
T.forEach((h) => {
|
|
1856
1860
|
let _ = R.contents;
|
|
1857
1861
|
if (_ == null) {
|
|
1858
|
-
t.insertBefore(
|
|
1862
|
+
t.insertBefore(h.element, y);
|
|
1859
1863
|
return;
|
|
1860
1864
|
}
|
|
1861
1865
|
if (_ === y) {
|
|
1862
|
-
t.insertBefore(
|
|
1866
|
+
t.insertBefore(h.element, y);
|
|
1863
1867
|
return;
|
|
1864
1868
|
}
|
|
1865
|
-
if (_ ===
|
|
1869
|
+
if (_ === h.element) {
|
|
1866
1870
|
R.contents = _.nextSibling;
|
|
1867
1871
|
return;
|
|
1868
1872
|
}
|
|
1869
|
-
V(
|
|
1873
|
+
V(D[h.key], !1) ? (U.disposeElement(_), t.replaceChild(h.element, _), R.contents = h.element.nextSibling) : (t.insertBefore(h.element, _), R.contents = h.element.nextSibling);
|
|
1870
1874
|
});
|
|
1871
|
-
}, E =
|
|
1875
|
+
}, E = v.runWithDisposer(() => {
|
|
1872
1876
|
b();
|
|
1873
1877
|
}, void 0);
|
|
1874
|
-
|
|
1878
|
+
c.addDisposer(G, E);
|
|
1875
1879
|
});
|
|
1876
1880
|
}
|
|
1877
1881
|
}
|
|
@@ -1882,45 +1886,45 @@ function Z(e, t) {
|
|
|
1882
1886
|
let n = e.children, r = e.events, i = e.attrs, l = N(t);
|
|
1883
1887
|
if (l === void 0)
|
|
1884
1888
|
return Le("Missing DOM element for Element node");
|
|
1885
|
-
let u = S(l), d =
|
|
1886
|
-
return
|
|
1889
|
+
let u = S(l), d = c.createOwner();
|
|
1890
|
+
return c.setOwner(u, d), c.runWithOwner(d, () => {
|
|
1887
1891
|
i.forEach((b) => {
|
|
1888
1892
|
let E = b[1], P = b[0];
|
|
1889
1893
|
switch (E.TAG) {
|
|
1890
1894
|
case "Static":
|
|
1891
1895
|
return;
|
|
1892
1896
|
case "SignalValue":
|
|
1893
|
-
let a = E._0, p =
|
|
1897
|
+
let a = E._0, p = v.runWithDisposer(() => {
|
|
1894
1898
|
pe.setAttrOrProp(u, P, o.get(a));
|
|
1895
1899
|
}, void 0);
|
|
1896
|
-
return
|
|
1900
|
+
return c.addDisposer(d, p);
|
|
1897
1901
|
case "Compute":
|
|
1898
|
-
let T = E._0,
|
|
1902
|
+
let T = E._0, D = v.runWithDisposer(() => {
|
|
1899
1903
|
pe.setAttrOrProp(u, P, T());
|
|
1900
1904
|
}, void 0);
|
|
1901
|
-
return
|
|
1905
|
+
return c.addDisposer(d, D);
|
|
1902
1906
|
}
|
|
1903
1907
|
}), r.forEach((b) => {
|
|
1904
1908
|
u.addEventListener(b[0], b[1]);
|
|
1905
1909
|
});
|
|
1906
|
-
let f =
|
|
1910
|
+
let f = se(u);
|
|
1907
1911
|
n.forEach((b) => Z(b, f));
|
|
1908
1912
|
});
|
|
1909
1913
|
case "Text":
|
|
1910
1914
|
N(t);
|
|
1911
1915
|
return;
|
|
1912
1916
|
case "SignalText":
|
|
1913
|
-
let
|
|
1917
|
+
let s = e._0;
|
|
1914
1918
|
K(t, "$");
|
|
1915
1919
|
let g = N(t);
|
|
1916
1920
|
if (g === void 0)
|
|
1917
1921
|
return Le("Missing text node for SignalText");
|
|
1918
|
-
let
|
|
1919
|
-
|
|
1920
|
-
let f =
|
|
1921
|
-
|
|
1922
|
+
let x = S(g), j = c.createOwner();
|
|
1923
|
+
c.setOwner(x, j), c.runWithOwner(j, () => {
|
|
1924
|
+
let f = v.runWithDisposer(() => {
|
|
1925
|
+
x.textContent = o.get(s);
|
|
1922
1926
|
}, void 0);
|
|
1923
|
-
|
|
1927
|
+
c.addDisposer(j, f);
|
|
1924
1928
|
}), K(t, "/$");
|
|
1925
1929
|
return;
|
|
1926
1930
|
case "Fragment":
|
|
@@ -1929,27 +1933,27 @@ function Z(e, t) {
|
|
|
1929
1933
|
case "SignalFragment":
|
|
1930
1934
|
let F = e._0;
|
|
1931
1935
|
K(t, "#");
|
|
1932
|
-
let
|
|
1933
|
-
|
|
1934
|
-
let
|
|
1935
|
-
|
|
1936
|
-
|
|
1936
|
+
let C = $e(t, "/#"), $ = document.createElement("div");
|
|
1937
|
+
$.setAttribute("style", "display: contents");
|
|
1938
|
+
let B = C[0], I = B !== void 0 ? B.parentNode : void 0;
|
|
1939
|
+
C.forEach((f) => {
|
|
1940
|
+
$.appendChild(f);
|
|
1937
1941
|
});
|
|
1938
|
-
let
|
|
1939
|
-
if (
|
|
1940
|
-
let f = S(
|
|
1941
|
-
|
|
1942
|
+
let G = t.current;
|
|
1943
|
+
if (I !== void 0) {
|
|
1944
|
+
let f = S(I);
|
|
1945
|
+
G !== void 0 ? f.insertBefore($, S(G)) : f.appendChild($);
|
|
1942
1946
|
}
|
|
1943
|
-
let
|
|
1944
|
-
return
|
|
1945
|
-
let f =
|
|
1947
|
+
let O = c.createOwner();
|
|
1948
|
+
return c.setOwner($, O), c.runWithOwner(O, () => {
|
|
1949
|
+
let f = v.runWithDisposer(() => {
|
|
1946
1950
|
let b = o.get(F);
|
|
1947
|
-
Array.from(
|
|
1951
|
+
Array.from($.childNodes || []).forEach(U.disposeElement), $.innerHTML = "", b.forEach((P) => {
|
|
1948
1952
|
let a = U.render(P);
|
|
1949
|
-
|
|
1953
|
+
$.appendChild(a);
|
|
1950
1954
|
});
|
|
1951
1955
|
}, void 0);
|
|
1952
|
-
|
|
1956
|
+
c.addDisposer(O, f);
|
|
1953
1957
|
});
|
|
1954
1958
|
case "LazyComponent":
|
|
1955
1959
|
K(t, "lc");
|
|
@@ -1974,98 +1978,99 @@ function Z(e, t) {
|
|
|
1974
1978
|
N(t);
|
|
1975
1979
|
let a = $e(t, "/k").find((p) => p.nodeType === 1);
|
|
1976
1980
|
if (a !== void 0) {
|
|
1977
|
-
let p = o.peek(k), T = V(p.find((
|
|
1981
|
+
let p = o.peek(k), T = V(p.find((D) => le(D) === E), {});
|
|
1978
1982
|
S(a);
|
|
1979
1983
|
}
|
|
1980
1984
|
}
|
|
1981
1985
|
})();
|
|
1982
1986
|
}
|
|
1983
1987
|
}
|
|
1984
|
-
function
|
|
1985
|
-
let r = n !== void 0 ? n : {}, i = e(), l =
|
|
1988
|
+
function nn(e, t, n) {
|
|
1989
|
+
let r = n !== void 0 ? n : {}, i = e(), l = se(t), u = l.current;
|
|
1986
1990
|
u !== void 0 && Pe(S(u), "xote-root:") && N(l), Z(i, l), window.__XOTE_HYDRATED__ = !0;
|
|
1987
1991
|
let d = r.onHydrated;
|
|
1988
1992
|
if (d !== void 0)
|
|
1989
1993
|
return d();
|
|
1990
1994
|
}
|
|
1991
|
-
function
|
|
1995
|
+
function $l(e, t, n) {
|
|
1992
1996
|
let r = n !== void 0 ? n : {}, i = document.getElementById(t);
|
|
1993
1997
|
if (i == null) {
|
|
1994
1998
|
console.error("[Xote Hydration] Container element not found: " + t);
|
|
1995
1999
|
return;
|
|
1996
2000
|
} else
|
|
1997
|
-
return
|
|
2001
|
+
return nn(e, i, r);
|
|
1998
2002
|
}
|
|
1999
|
-
let
|
|
2003
|
+
let Dl, xl, Al;
|
|
2000
2004
|
const Cl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
2001
2005
|
__proto__: null,
|
|
2002
|
-
Component:
|
|
2006
|
+
Component: Dl,
|
|
2003
2007
|
DOM: xl,
|
|
2004
|
-
DOMWalker:
|
|
2005
|
-
HydrationMismatch:
|
|
2008
|
+
DOMWalker: kl,
|
|
2009
|
+
HydrationMismatch: Tl,
|
|
2006
2010
|
Reactivity: Al,
|
|
2007
|
-
hydrate:
|
|
2008
|
-
hydrateById:
|
|
2009
|
-
hydrateNode:
|
|
2011
|
+
hydrate: nn,
|
|
2012
|
+
hydrateById: $l,
|
|
2013
|
+
hydrateNode: vl,
|
|
2010
2014
|
hydrateNodeWithWalker: Z,
|
|
2011
2015
|
logHydrationWarning: Le
|
|
2012
2016
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
2013
2017
|
function Ol(e) {
|
|
2014
2018
|
return e.TAG === "Reactive" ? o.get(e._0) : e._0;
|
|
2015
2019
|
}
|
|
2016
|
-
function
|
|
2020
|
+
function Pl(e) {
|
|
2017
2021
|
return {
|
|
2018
2022
|
TAG: "Static",
|
|
2019
2023
|
_0: e
|
|
2020
2024
|
};
|
|
2021
2025
|
}
|
|
2022
|
-
function
|
|
2026
|
+
function Rl(e) {
|
|
2023
2027
|
return {
|
|
2024
2028
|
TAG: "Reactive",
|
|
2025
2029
|
_0: e
|
|
2026
2030
|
};
|
|
2027
2031
|
}
|
|
2028
|
-
const
|
|
2032
|
+
const Ml = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
2029
2033
|
__proto__: null,
|
|
2030
|
-
$$static:
|
|
2034
|
+
$$static: Pl,
|
|
2031
2035
|
get: Ol,
|
|
2032
|
-
reactive:
|
|
2036
|
+
reactive: Rl
|
|
2033
2037
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
2034
|
-
let
|
|
2035
|
-
Id:
|
|
2036
|
-
Scheduler:
|
|
2037
|
-
Core:
|
|
2038
|
-
make:
|
|
2039
|
-
makeForComputed:
|
|
2038
|
+
let jl = o.Id, Fl = o.Scheduler, Nl = o.Core, Ll = o.make, Wl = o.makeForComputed, Il = o.get, Gl = o.peek, zl = o.set, Bl = o.update, Hl = o.batch, Xl = o.untrack, ri = {
|
|
2039
|
+
Id: jl,
|
|
2040
|
+
Scheduler: Fl,
|
|
2041
|
+
Core: Nl,
|
|
2042
|
+
make: Ll,
|
|
2043
|
+
makeForComputed: Wl,
|
|
2040
2044
|
get: Il,
|
|
2041
2045
|
peek: Gl,
|
|
2042
2046
|
set: zl,
|
|
2043
2047
|
update: Bl,
|
|
2044
|
-
batch:
|
|
2045
|
-
untrack:
|
|
2046
|
-
},
|
|
2047
|
-
Id:
|
|
2048
|
-
Signal:
|
|
2049
|
-
Core:
|
|
2050
|
-
Scheduler:
|
|
2051
|
-
make:
|
|
2052
|
-
dispose:
|
|
2053
|
-
},
|
|
2054
|
-
Id:
|
|
2055
|
-
Core:
|
|
2056
|
-
Scheduler:
|
|
2057
|
-
|
|
2058
|
-
|
|
2048
|
+
batch: Hl,
|
|
2049
|
+
untrack: Xl
|
|
2050
|
+
}, Vl = M.Id, Kl = M.Signal, Yl = M.Core, ql = M.Scheduler, Ul = M.make, Jl = M.dispose, li = {
|
|
2051
|
+
Id: Vl,
|
|
2052
|
+
Signal: Kl,
|
|
2053
|
+
Core: Yl,
|
|
2054
|
+
Scheduler: ql,
|
|
2055
|
+
make: Ul,
|
|
2056
|
+
dispose: Jl
|
|
2057
|
+
}, Ql = v.Id, Zl = v.Core, ei = v.Scheduler, ti = v.runWithDisposer, ni = v.run, ii = {
|
|
2058
|
+
Id: Ql,
|
|
2059
|
+
Core: Zl,
|
|
2060
|
+
Scheduler: ei,
|
|
2061
|
+
runWithDisposer: ti,
|
|
2062
|
+
run: ni
|
|
2063
|
+
}, ui = xr, oi = tr, di = Gr, ai = Ml, si = Zn, ci = Ur, fi = yl, pi = Cl;
|
|
2059
2064
|
export {
|
|
2060
|
-
|
|
2061
|
-
|
|
2062
|
-
|
|
2063
|
-
|
|
2064
|
-
|
|
2065
|
-
|
|
2066
|
-
|
|
2067
|
-
|
|
2068
|
-
|
|
2069
|
-
|
|
2070
|
-
|
|
2065
|
+
ui as Component,
|
|
2066
|
+
li as Computed,
|
|
2067
|
+
ii as Effect,
|
|
2068
|
+
pi as Hydration,
|
|
2069
|
+
ai as ReactiveProp,
|
|
2070
|
+
oi as Route,
|
|
2071
|
+
di as Router,
|
|
2072
|
+
si as SSR,
|
|
2073
|
+
ci as SSRContext,
|
|
2074
|
+
fi as SSRState,
|
|
2075
|
+
ri as Signal
|
|
2071
2076
|
};
|