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