xote 4.4.0 → 4.4.2
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 +1 -1
- package/dist/xote.mjs +311 -297
- package/dist/xote.umd.js +1 -1
- package/package.json +1 -1
- package/src/Xote__Component.res +15 -5
- package/src/Xote__Component.res.mjs +22 -7
- package/src/Xote__JSX.res +114 -24
- package/src/Xote__JSX.res.mjs +95 -82
package/dist/xote.mjs
CHANGED
|
@@ -1,10 +1,10 @@
|
|
|
1
|
-
let
|
|
1
|
+
let J = {
|
|
2
2
|
contents: 0
|
|
3
3
|
};
|
|
4
|
-
function
|
|
5
|
-
return
|
|
4
|
+
function Y() {
|
|
5
|
+
return J.contents = J.contents + 1 | 0, J.contents;
|
|
6
6
|
}
|
|
7
|
-
function
|
|
7
|
+
function Pe(e) {
|
|
8
8
|
return e === void 0 ? {
|
|
9
9
|
BS_PRIVATE_NESTED_SOME_NONE: 0
|
|
10
10
|
} : e !== null && e.BS_PRIVATE_NESTED_SOME_NONE !== void 0 ? {
|
|
@@ -13,9 +13,9 @@ function xe(e) {
|
|
|
13
13
|
}
|
|
14
14
|
function Re(e) {
|
|
15
15
|
if (e != null)
|
|
16
|
-
return
|
|
16
|
+
return Pe(e);
|
|
17
17
|
}
|
|
18
|
-
function
|
|
18
|
+
function ce(e) {
|
|
19
19
|
if (e === null || e.BS_PRIVATE_NESTED_SOME_NONE === void 0)
|
|
20
20
|
return e;
|
|
21
21
|
let t = e.BS_PRIVATE_NESTED_SOME_NONE;
|
|
@@ -24,8 +24,8 @@ function oe(e) {
|
|
|
24
24
|
BS_PRIVATE_NESTED_SOME_NONE: t - 1 | 0
|
|
25
25
|
};
|
|
26
26
|
}
|
|
27
|
-
function
|
|
28
|
-
return e !== void 0 ?
|
|
27
|
+
function Z(e, t) {
|
|
28
|
+
return e !== void 0 ? ce(e) : t;
|
|
29
29
|
}
|
|
30
30
|
function De(e, t, n) {
|
|
31
31
|
return e.reduce(n, t);
|
|
@@ -34,7 +34,7 @@ function Fe(e, t) {
|
|
|
34
34
|
let n = e.length, r = new Array(n), l = 0;
|
|
35
35
|
for (let u = 0; u < n; ++u) {
|
|
36
36
|
let a = e[u], o = t(a);
|
|
37
|
-
o !== void 0 && (r[l] =
|
|
37
|
+
o !== void 0 && (r[l] = ce(o), l = l + 1 | 0);
|
|
38
38
|
}
|
|
39
39
|
return r.length = l, r;
|
|
40
40
|
}
|
|
@@ -50,44 +50,44 @@ function Le(e, t) {
|
|
|
50
50
|
n = r + 1 | 0;
|
|
51
51
|
}
|
|
52
52
|
}
|
|
53
|
-
let h = /* @__PURE__ */ new Map(),
|
|
53
|
+
let h = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), G = /* @__PURE__ */ new Map(), p = {
|
|
54
54
|
contents: void 0
|
|
55
|
-
},
|
|
55
|
+
}, j = /* @__PURE__ */ new Set(), k = {
|
|
56
56
|
contents: !1
|
|
57
57
|
}, y = {
|
|
58
58
|
contents: !1
|
|
59
59
|
};
|
|
60
|
-
function
|
|
61
|
-
if (
|
|
62
|
-
|
|
60
|
+
function ee(e) {
|
|
61
|
+
if (x.get(e) === void 0) {
|
|
62
|
+
x.set(e, /* @__PURE__ */ new Set());
|
|
63
63
|
return;
|
|
64
64
|
}
|
|
65
65
|
}
|
|
66
|
-
function
|
|
67
|
-
let n =
|
|
66
|
+
function Ge(e, t) {
|
|
67
|
+
let n = x.get(e);
|
|
68
68
|
if (n !== void 0) {
|
|
69
69
|
n.forEach(t);
|
|
70
70
|
return;
|
|
71
71
|
}
|
|
72
72
|
}
|
|
73
|
-
function
|
|
74
|
-
let n =
|
|
73
|
+
function Be(e, t) {
|
|
74
|
+
let n = x.get(e);
|
|
75
75
|
if (n !== void 0) {
|
|
76
76
|
n.add(t);
|
|
77
77
|
return;
|
|
78
78
|
}
|
|
79
79
|
}
|
|
80
|
-
function
|
|
81
|
-
let n =
|
|
80
|
+
function Ve(e, t) {
|
|
81
|
+
let n = x.get(e);
|
|
82
82
|
if (n !== void 0) {
|
|
83
83
|
n.delete(t);
|
|
84
84
|
return;
|
|
85
85
|
}
|
|
86
86
|
}
|
|
87
|
-
function
|
|
88
|
-
return Array.from(
|
|
87
|
+
function ze(e) {
|
|
88
|
+
return Array.from(Z(x.get(e), /* @__PURE__ */ new Set()).values());
|
|
89
89
|
}
|
|
90
|
-
function
|
|
90
|
+
function de(e, t) {
|
|
91
91
|
let n = p.contents;
|
|
92
92
|
p.contents = e;
|
|
93
93
|
try {
|
|
@@ -97,7 +97,7 @@ function ce(e, t) {
|
|
|
97
97
|
throw p.contents = n, r;
|
|
98
98
|
}
|
|
99
99
|
}
|
|
100
|
-
function
|
|
100
|
+
function We(e) {
|
|
101
101
|
let t = p.contents;
|
|
102
102
|
p.contents = void 0;
|
|
103
103
|
try {
|
|
@@ -107,11 +107,11 @@ function ze(e) {
|
|
|
107
107
|
throw p.contents = t, n;
|
|
108
108
|
}
|
|
109
109
|
}
|
|
110
|
-
function
|
|
110
|
+
function Ke(e) {
|
|
111
111
|
let t = p.contents;
|
|
112
112
|
return t !== void 0 ? t === e : !1;
|
|
113
113
|
}
|
|
114
|
-
function
|
|
114
|
+
function Xe(e) {
|
|
115
115
|
if (!k.contents) {
|
|
116
116
|
k.contents = !0;
|
|
117
117
|
try {
|
|
@@ -122,32 +122,32 @@ function Ke(e) {
|
|
|
122
122
|
}
|
|
123
123
|
}
|
|
124
124
|
}
|
|
125
|
-
function
|
|
126
|
-
|
|
127
|
-
let n =
|
|
125
|
+
function qe(e, t) {
|
|
126
|
+
ee(t);
|
|
127
|
+
let n = Ke(e), r = h.get(e);
|
|
128
128
|
if (n && r !== void 0 && !r.deps.has(t))
|
|
129
|
-
return r.deps.add(t),
|
|
129
|
+
return r.deps.add(t), Be(t, e);
|
|
130
130
|
}
|
|
131
|
-
function
|
|
132
|
-
e.deps.forEach((t) =>
|
|
131
|
+
function P(e) {
|
|
132
|
+
e.deps.forEach((t) => Ve(t, e.id)), e.deps.clear();
|
|
133
133
|
}
|
|
134
|
-
function
|
|
135
|
-
let t =
|
|
134
|
+
function He(e) {
|
|
135
|
+
let t = G.get(e);
|
|
136
136
|
if (t === void 0)
|
|
137
137
|
return;
|
|
138
|
-
|
|
138
|
+
G.delete(e);
|
|
139
139
|
let n = h.get(t);
|
|
140
140
|
if (n !== void 0) {
|
|
141
|
-
|
|
141
|
+
P(n), h.delete(t);
|
|
142
142
|
return;
|
|
143
143
|
}
|
|
144
144
|
}
|
|
145
|
-
function
|
|
145
|
+
function se(e) {
|
|
146
146
|
return De(e, 0, (t, n) => n > t ? n : t);
|
|
147
147
|
}
|
|
148
|
-
function
|
|
148
|
+
function Ue(e) {
|
|
149
149
|
let t = [];
|
|
150
|
-
return e.deps.forEach((n) =>
|
|
150
|
+
return e.deps.forEach((n) => Ge(n, (r) => {
|
|
151
151
|
if (r === e.id)
|
|
152
152
|
return;
|
|
153
153
|
let l = h.get(r);
|
|
@@ -157,12 +157,12 @@ function He(e) {
|
|
|
157
157
|
t.push(l.level);
|
|
158
158
|
return;
|
|
159
159
|
}
|
|
160
|
-
})),
|
|
160
|
+
})), se(t) + 1 | 0;
|
|
161
161
|
}
|
|
162
|
-
function
|
|
162
|
+
function Je(e) {
|
|
163
163
|
let t = [];
|
|
164
164
|
return e.deps.forEach((n) => {
|
|
165
|
-
let r =
|
|
165
|
+
let r = G.get(n);
|
|
166
166
|
if (r === void 0 || r === e.id)
|
|
167
167
|
return;
|
|
168
168
|
let l = h.get(r);
|
|
@@ -170,12 +170,12 @@ function Ue(e) {
|
|
|
170
170
|
t.push(l.level);
|
|
171
171
|
return;
|
|
172
172
|
}
|
|
173
|
-
}),
|
|
173
|
+
}), se(t) + 1 | 0;
|
|
174
174
|
}
|
|
175
|
-
function
|
|
176
|
-
return typeof e.kind == "object" ?
|
|
175
|
+
function W(e) {
|
|
176
|
+
return typeof e.kind == "object" ? Je(e) : Ue(e);
|
|
177
177
|
}
|
|
178
|
-
function
|
|
178
|
+
function Qe(e, t) {
|
|
179
179
|
let n = h.get(e), r = h.get(t);
|
|
180
180
|
if (n === void 0)
|
|
181
181
|
return r !== void 0 ? 1 : 0;
|
|
@@ -184,59 +184,59 @@ function Je(e, t) {
|
|
|
184
184
|
let u = typeof n.kind == "object" ? 0 : 1, o = typeof r.kind == "object" ? 0 : 1, c = u - o | 0;
|
|
185
185
|
return c !== 0 ? c : n.level - r.level | 0;
|
|
186
186
|
}
|
|
187
|
-
function
|
|
188
|
-
y.contents = !0,
|
|
187
|
+
function Ye(e) {
|
|
188
|
+
y.contents = !0, P(e), de(e.id, () => {
|
|
189
189
|
e.run(), y.contents = !1;
|
|
190
|
-
}), e.level =
|
|
190
|
+
}), e.level = W(e);
|
|
191
191
|
}
|
|
192
|
-
function
|
|
193
|
-
for (;
|
|
194
|
-
let e = Array.from(
|
|
195
|
-
|
|
192
|
+
function ae() {
|
|
193
|
+
for (; j.size > 0; ) {
|
|
194
|
+
let e = Array.from(j.values());
|
|
195
|
+
j.clear(), e.sort(Qe), e.forEach((t) => {
|
|
196
196
|
let n = h.get(t);
|
|
197
197
|
if (n !== void 0)
|
|
198
|
-
return
|
|
198
|
+
return Ye(n);
|
|
199
199
|
});
|
|
200
200
|
}
|
|
201
201
|
}
|
|
202
|
-
function
|
|
203
|
-
if (
|
|
202
|
+
function fe(e) {
|
|
203
|
+
if (ee(e), ze(e).forEach((t) => {
|
|
204
204
|
let n = h.get(t);
|
|
205
205
|
if (n === void 0)
|
|
206
206
|
return;
|
|
207
207
|
let r = n.kind;
|
|
208
208
|
if (typeof r == "object")
|
|
209
|
-
return n.dirty ? void 0 : (n.dirty = !0,
|
|
210
|
-
|
|
211
|
-
}),
|
|
212
|
-
return
|
|
209
|
+
return n.dirty ? void 0 : (n.dirty = !0, fe(r.VAL));
|
|
210
|
+
j.add(t);
|
|
211
|
+
}), j.size > 0)
|
|
212
|
+
return Xe(ae);
|
|
213
213
|
}
|
|
214
|
-
function
|
|
215
|
-
let t =
|
|
214
|
+
function pe(e) {
|
|
215
|
+
let t = G.get(e);
|
|
216
216
|
if (t === void 0)
|
|
217
217
|
return;
|
|
218
218
|
let n = h.get(t);
|
|
219
219
|
if (n !== void 0 && n.dirty) {
|
|
220
|
-
y.contents = !0,
|
|
220
|
+
y.contents = !0, P(n), de(t, () => {
|
|
221
221
|
n.run(), n.dirty = !1, y.contents = !1;
|
|
222
|
-
}), n.level =
|
|
222
|
+
}), n.level = W(n);
|
|
223
223
|
return;
|
|
224
224
|
}
|
|
225
225
|
}
|
|
226
|
-
function
|
|
226
|
+
function Ze(e) {
|
|
227
227
|
let t = k.contents;
|
|
228
228
|
k.contents = !0;
|
|
229
229
|
try {
|
|
230
230
|
let n = e();
|
|
231
|
-
return t || (k.contents = !1,
|
|
231
|
+
return t || (k.contents = !1, j.size > 0 && ae()), n;
|
|
232
232
|
} catch (n) {
|
|
233
233
|
throw t || (k.contents = !1), n;
|
|
234
234
|
}
|
|
235
235
|
}
|
|
236
|
-
let
|
|
237
|
-
function
|
|
238
|
-
let r =
|
|
239
|
-
return
|
|
236
|
+
let et = We, tt = ee;
|
|
237
|
+
function me(e, t, n) {
|
|
238
|
+
let r = Y();
|
|
239
|
+
return tt(r), {
|
|
240
240
|
id: r,
|
|
241
241
|
value: {
|
|
242
242
|
contents: e
|
|
@@ -244,19 +244,19 @@ function pe(e, t, n) {
|
|
|
244
244
|
version: {
|
|
245
245
|
contents: 0
|
|
246
246
|
},
|
|
247
|
-
equals:
|
|
247
|
+
equals: Z(n, (l, u) => l === u),
|
|
248
248
|
name: t
|
|
249
249
|
};
|
|
250
250
|
}
|
|
251
|
-
function
|
|
252
|
-
|
|
251
|
+
function nt(e) {
|
|
252
|
+
pe(e.id);
|
|
253
253
|
let t = p.contents;
|
|
254
|
-
return t !== void 0 &&
|
|
254
|
+
return t !== void 0 && qe(t, e.id), e.value.contents;
|
|
255
255
|
}
|
|
256
|
-
function
|
|
257
|
-
return
|
|
256
|
+
function rt(e) {
|
|
257
|
+
return pe(e.id), e.value.contents;
|
|
258
258
|
}
|
|
259
|
-
function
|
|
259
|
+
function he(e, t) {
|
|
260
260
|
let n;
|
|
261
261
|
try {
|
|
262
262
|
n = !e.equals(e.value.contents, t);
|
|
@@ -264,25 +264,25 @@ function me(e, t) {
|
|
|
264
264
|
n = !0;
|
|
265
265
|
}
|
|
266
266
|
if (n)
|
|
267
|
-
return e.value.contents = t, e.version.contents = e.version.contents + 1 | 0,
|
|
267
|
+
return e.value.contents = t, e.version.contents = e.version.contents + 1 | 0, fe(e.id);
|
|
268
268
|
}
|
|
269
|
-
function
|
|
270
|
-
|
|
269
|
+
function lt(e, t) {
|
|
270
|
+
he(e, t(e.value.contents));
|
|
271
271
|
}
|
|
272
|
-
let
|
|
273
|
-
const
|
|
272
|
+
let ut, it, ot = Ze, ct = et;
|
|
273
|
+
const dt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
274
274
|
__proto__: null,
|
|
275
|
-
Id:
|
|
276
|
-
Scheduler:
|
|
277
|
-
batch:
|
|
278
|
-
get:
|
|
279
|
-
make:
|
|
280
|
-
peek:
|
|
281
|
-
set:
|
|
282
|
-
untrack:
|
|
283
|
-
update:
|
|
275
|
+
Id: ut,
|
|
276
|
+
Scheduler: it,
|
|
277
|
+
batch: ot,
|
|
278
|
+
get: nt,
|
|
279
|
+
make: me,
|
|
280
|
+
peek: rt,
|
|
281
|
+
set: he,
|
|
282
|
+
untrack: ct,
|
|
283
|
+
update: lt
|
|
284
284
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
285
|
-
function
|
|
285
|
+
function _e(e, t, n, r) {
|
|
286
286
|
return {
|
|
287
287
|
id: e,
|
|
288
288
|
kind: t,
|
|
@@ -293,14 +293,14 @@ function he(e, t, n, r) {
|
|
|
293
293
|
name: r
|
|
294
294
|
};
|
|
295
295
|
}
|
|
296
|
-
function
|
|
297
|
-
let n =
|
|
296
|
+
function st(e, t) {
|
|
297
|
+
let n = Y(), r = {
|
|
298
298
|
contents: void 0
|
|
299
|
-
}, u =
|
|
299
|
+
}, u = _e(n, "Effect", () => {
|
|
300
300
|
let c = r.contents;
|
|
301
301
|
c !== void 0 && c(), r.contents = e();
|
|
302
302
|
}, t);
|
|
303
|
-
h.set(n, u), y.contents = !0,
|
|
303
|
+
h.set(n, u), y.contents = !0, P(u);
|
|
304
304
|
let a = p.contents;
|
|
305
305
|
p.contents = n;
|
|
306
306
|
try {
|
|
@@ -308,33 +308,33 @@ function dt(e, t) {
|
|
|
308
308
|
} catch (c) {
|
|
309
309
|
throw p.contents = a, y.contents = !1, c;
|
|
310
310
|
}
|
|
311
|
-
return p.contents = a, u.level =
|
|
311
|
+
return p.contents = a, u.level = W(u), {
|
|
312
312
|
dispose: () => {
|
|
313
313
|
let c = h.get(n);
|
|
314
314
|
if (c === void 0)
|
|
315
315
|
return;
|
|
316
316
|
let R = r.contents;
|
|
317
|
-
R !== void 0 && R(),
|
|
317
|
+
R !== void 0 && R(), P(c), h.delete(n);
|
|
318
318
|
}
|
|
319
319
|
};
|
|
320
320
|
}
|
|
321
|
-
let
|
|
322
|
-
const
|
|
321
|
+
let at, ft, pt;
|
|
322
|
+
const mt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
323
323
|
__proto__: null,
|
|
324
|
-
Id:
|
|
325
|
-
Observer:
|
|
326
|
-
Scheduler:
|
|
327
|
-
run:
|
|
324
|
+
Id: at,
|
|
325
|
+
Observer: ft,
|
|
326
|
+
Scheduler: pt,
|
|
327
|
+
run: st
|
|
328
328
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
329
|
-
function
|
|
330
|
-
let n =
|
|
329
|
+
function ht(e, t) {
|
|
330
|
+
let n = me(void 0, t, void 0), r = Y(), l = () => {
|
|
331
331
|
let o = e();
|
|
332
332
|
n.value.contents = o;
|
|
333
|
-
}, u =
|
|
333
|
+
}, u = _e(r, {
|
|
334
334
|
NAME: "Computed",
|
|
335
335
|
VAL: n.id
|
|
336
336
|
}, l, void 0);
|
|
337
|
-
h.set(r, u), y.contents = !0,
|
|
337
|
+
h.set(r, u), y.contents = !0, P(u);
|
|
338
338
|
let a = p.contents;
|
|
339
339
|
p.contents = r;
|
|
340
340
|
try {
|
|
@@ -342,23 +342,23 @@ function mt(e, t) {
|
|
|
342
342
|
} catch (o) {
|
|
343
343
|
throw p.contents = a, y.contents = !1, o;
|
|
344
344
|
}
|
|
345
|
-
return p.contents = a, u.level =
|
|
345
|
+
return p.contents = a, u.level = W(u), G.set(n.id, r), n;
|
|
346
346
|
}
|
|
347
|
-
function
|
|
348
|
-
|
|
347
|
+
function _t(e) {
|
|
348
|
+
He(e.id);
|
|
349
349
|
}
|
|
350
|
-
let
|
|
351
|
-
const
|
|
350
|
+
let gt, St, Et, vt;
|
|
351
|
+
const yt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
352
352
|
__proto__: null,
|
|
353
|
-
Id:
|
|
354
|
-
Observer:
|
|
355
|
-
Scheduler:
|
|
356
|
-
Signal:
|
|
357
|
-
dispose:
|
|
358
|
-
make:
|
|
353
|
+
Id: gt,
|
|
354
|
+
Observer: Et,
|
|
355
|
+
Scheduler: vt,
|
|
356
|
+
Signal: St,
|
|
357
|
+
dispose: _t,
|
|
358
|
+
make: ht
|
|
359
359
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
360
|
-
let s =
|
|
361
|
-
function
|
|
360
|
+
let s = dt, S = yt, w = mt;
|
|
361
|
+
function ge(e) {
|
|
362
362
|
return Fe(e.split("/"), (t) => {
|
|
363
363
|
if (t !== "")
|
|
364
364
|
return t.startsWith(":") ? {
|
|
@@ -370,7 +370,7 @@ function _e(e) {
|
|
|
370
370
|
};
|
|
371
371
|
});
|
|
372
372
|
}
|
|
373
|
-
function
|
|
373
|
+
function Se(e, t) {
|
|
374
374
|
let n = t.split("/").filter((u) => u !== "");
|
|
375
375
|
if (e.length !== n.length)
|
|
376
376
|
return "NoMatch";
|
|
@@ -383,55 +383,70 @@ function ge(e, t) {
|
|
|
383
383
|
_0: r
|
|
384
384
|
} : "NoMatch";
|
|
385
385
|
}
|
|
386
|
-
function
|
|
387
|
-
return ge(
|
|
386
|
+
function te(e, t) {
|
|
387
|
+
return Se(ge(e), t);
|
|
388
388
|
}
|
|
389
|
-
const
|
|
389
|
+
const bt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
390
390
|
__proto__: null,
|
|
391
|
-
match:
|
|
392
|
-
matchPath:
|
|
393
|
-
parsePattern:
|
|
391
|
+
match: te,
|
|
392
|
+
matchPath: Se,
|
|
393
|
+
parsePattern: ge
|
|
394
394
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
395
|
-
function
|
|
395
|
+
function wt(e, t) {
|
|
396
396
|
delete e[t];
|
|
397
397
|
}
|
|
398
|
-
|
|
398
|
+
function C(e, t, n) {
|
|
399
|
+
switch (t) {
|
|
400
|
+
case "checked":
|
|
401
|
+
e.checked = n === "true";
|
|
402
|
+
return;
|
|
403
|
+
case "value":
|
|
404
|
+
e.value = n;
|
|
405
|
+
return;
|
|
406
|
+
default:
|
|
407
|
+
e.setAttribute(t, n);
|
|
408
|
+
return;
|
|
409
|
+
}
|
|
410
|
+
}
|
|
411
|
+
let kt = {
|
|
412
|
+
setAttrOrProp: C
|
|
413
|
+
}, z = {
|
|
399
414
|
contents: void 0
|
|
400
415
|
};
|
|
401
|
-
function
|
|
416
|
+
function Ot() {
|
|
402
417
|
return {
|
|
403
418
|
disposers: [],
|
|
404
419
|
computeds: []
|
|
405
420
|
};
|
|
406
421
|
}
|
|
407
|
-
function
|
|
408
|
-
let n =
|
|
409
|
-
|
|
422
|
+
function N(e, t) {
|
|
423
|
+
let n = z.contents;
|
|
424
|
+
z.contents = e;
|
|
410
425
|
let r = t();
|
|
411
|
-
return
|
|
426
|
+
return z.contents = n, r;
|
|
412
427
|
}
|
|
413
|
-
function
|
|
428
|
+
function M(e, t) {
|
|
414
429
|
e.disposers.push(t);
|
|
415
430
|
}
|
|
416
|
-
function
|
|
431
|
+
function Ee(e) {
|
|
417
432
|
e.disposers.forEach((t) => t.dispose()), e.computeds.forEach((t) => S.dispose(t));
|
|
418
433
|
}
|
|
419
|
-
function
|
|
434
|
+
function I(e, t) {
|
|
420
435
|
e.__xote_owner__ = t;
|
|
421
436
|
}
|
|
422
|
-
function
|
|
437
|
+
function ve(e) {
|
|
423
438
|
return Re(e.__xote_owner__);
|
|
424
439
|
}
|
|
425
|
-
let
|
|
426
|
-
currentOwner:
|
|
427
|
-
createOwner:
|
|
428
|
-
runWithOwner:
|
|
429
|
-
addDisposer:
|
|
430
|
-
disposeOwner:
|
|
431
|
-
setOwner:
|
|
432
|
-
getOwner:
|
|
440
|
+
let Tt = {
|
|
441
|
+
currentOwner: z,
|
|
442
|
+
createOwner: Ot,
|
|
443
|
+
runWithOwner: N,
|
|
444
|
+
addDisposer: M,
|
|
445
|
+
disposeOwner: Ee,
|
|
446
|
+
setOwner: I,
|
|
447
|
+
getOwner: ve
|
|
433
448
|
};
|
|
434
|
-
function
|
|
449
|
+
function ye(e, t) {
|
|
435
450
|
return [
|
|
436
451
|
e,
|
|
437
452
|
{
|
|
@@ -440,7 +455,7 @@ function ve(e, t) {
|
|
|
440
455
|
}
|
|
441
456
|
];
|
|
442
457
|
}
|
|
443
|
-
function
|
|
458
|
+
function be(e, t) {
|
|
444
459
|
return [
|
|
445
460
|
e,
|
|
446
461
|
{
|
|
@@ -449,7 +464,7 @@ function ye(e, t) {
|
|
|
449
464
|
}
|
|
450
465
|
];
|
|
451
466
|
}
|
|
452
|
-
function
|
|
467
|
+
function we(e, t) {
|
|
453
468
|
return [
|
|
454
469
|
e,
|
|
455
470
|
{
|
|
@@ -458,14 +473,14 @@ function be(e, t) {
|
|
|
458
473
|
}
|
|
459
474
|
];
|
|
460
475
|
}
|
|
461
|
-
let
|
|
462
|
-
$$static:
|
|
463
|
-
signal:
|
|
464
|
-
computed:
|
|
476
|
+
let At = {
|
|
477
|
+
$$static: ye,
|
|
478
|
+
signal: be,
|
|
479
|
+
computed: we
|
|
465
480
|
};
|
|
466
481
|
function L(e) {
|
|
467
|
-
let t =
|
|
468
|
-
t !== void 0 &&
|
|
482
|
+
let t = ve(e);
|
|
483
|
+
t !== void 0 && Ee(t), Array.from(e.childNodes || []).forEach(L);
|
|
469
484
|
}
|
|
470
485
|
function b(e) {
|
|
471
486
|
switch (e.TAG) {
|
|
@@ -474,27 +489,26 @@ function b(e) {
|
|
|
474
489
|
disposers: [],
|
|
475
490
|
computeds: []
|
|
476
491
|
};
|
|
477
|
-
return
|
|
492
|
+
return I(l, u), N(u, () => {
|
|
478
493
|
r.forEach((i) => {
|
|
479
494
|
let m = i[1], g = i[0];
|
|
480
495
|
switch (m.TAG) {
|
|
481
496
|
case "Static":
|
|
482
|
-
l
|
|
483
|
-
return;
|
|
497
|
+
return C(l, g, m._0);
|
|
484
498
|
case "SignalValue":
|
|
485
499
|
let E = m._0;
|
|
486
|
-
l
|
|
500
|
+
C(l, g, s.peek(E));
|
|
487
501
|
let v = w.run(() => {
|
|
488
|
-
l
|
|
502
|
+
C(l, g, s.get(E));
|
|
489
503
|
}, void 0);
|
|
490
|
-
return
|
|
504
|
+
return M(u, v);
|
|
491
505
|
case "Compute":
|
|
492
506
|
let F = m._0;
|
|
493
|
-
l
|
|
507
|
+
C(l, g, F());
|
|
494
508
|
let $ = w.run(() => {
|
|
495
|
-
l
|
|
509
|
+
C(l, g, F());
|
|
496
510
|
}, void 0);
|
|
497
|
-
return
|
|
511
|
+
return M(u, $);
|
|
498
512
|
}
|
|
499
513
|
}), n.forEach((i) => {
|
|
500
514
|
l.addEventListener(i[0], i[1]);
|
|
@@ -510,11 +524,11 @@ function b(e) {
|
|
|
510
524
|
disposers: [],
|
|
511
525
|
computeds: []
|
|
512
526
|
};
|
|
513
|
-
return
|
|
527
|
+
return I(o, c), N(c, () => {
|
|
514
528
|
let i = w.run(() => {
|
|
515
529
|
o.textContent = s.get(a);
|
|
516
530
|
}, void 0);
|
|
517
|
-
|
|
531
|
+
M(c, i);
|
|
518
532
|
}), o;
|
|
519
533
|
case "Fragment":
|
|
520
534
|
let R = document.createDocumentFragment();
|
|
@@ -523,39 +537,39 @@ function b(e) {
|
|
|
523
537
|
R.appendChild(m);
|
|
524
538
|
}), R;
|
|
525
539
|
case "SignalFragment":
|
|
526
|
-
let
|
|
540
|
+
let $e = e._0, K = {
|
|
527
541
|
disposers: [],
|
|
528
542
|
computeds: []
|
|
529
543
|
}, A = document.createElement("div");
|
|
530
|
-
return A.setAttribute("style", "display: contents"),
|
|
544
|
+
return A.setAttribute("style", "display: contents"), I(A, K), N(K, () => {
|
|
531
545
|
let i = w.run(() => {
|
|
532
|
-
let m = s.get(
|
|
546
|
+
let m = s.get($e);
|
|
533
547
|
Array.from(A.childNodes || []).forEach(L), A.innerHTML = "", m.forEach((E) => {
|
|
534
548
|
let v = b(E);
|
|
535
549
|
A.appendChild(v);
|
|
536
550
|
});
|
|
537
551
|
}, void 0);
|
|
538
|
-
|
|
552
|
+
M(K, i);
|
|
539
553
|
}), A;
|
|
540
554
|
case "LazyComponent":
|
|
541
|
-
let
|
|
555
|
+
let re = {
|
|
542
556
|
disposers: [],
|
|
543
557
|
computeds: []
|
|
544
|
-
},
|
|
545
|
-
return
|
|
558
|
+
}, Ce = N(re, e._0), le = b(Ce);
|
|
559
|
+
return I(le, re), le;
|
|
546
560
|
case "KeyedList":
|
|
547
|
-
let
|
|
561
|
+
let X = e.renderItem, q = e.keyFn, ue = e.signal, H = {
|
|
548
562
|
disposers: [],
|
|
549
563
|
computeds: []
|
|
550
|
-
},
|
|
551
|
-
|
|
552
|
-
let O = {},
|
|
564
|
+
}, U = document.createComment(" keyed-list-start "), D = document.createComment(" keyed-list-end ");
|
|
565
|
+
I(U, H);
|
|
566
|
+
let O = {}, Ne = () => {
|
|
553
567
|
let i = D.parentNode;
|
|
554
568
|
if (i == null)
|
|
555
569
|
return;
|
|
556
|
-
let m = s.get(
|
|
570
|
+
let m = s.get(ue), g = {};
|
|
557
571
|
m.forEach((d) => {
|
|
558
|
-
g[
|
|
572
|
+
g[q(d)] = d;
|
|
559
573
|
});
|
|
560
574
|
let E = [];
|
|
561
575
|
Object.keys(O).forEach((d) => {
|
|
@@ -566,36 +580,36 @@ function b(e) {
|
|
|
566
580
|
}), E.forEach((d) => {
|
|
567
581
|
let f = O[d];
|
|
568
582
|
if (f !== void 0) {
|
|
569
|
-
L(f.element), f.element.remove(),
|
|
583
|
+
L(f.element), f.element.remove(), wt(O, d);
|
|
570
584
|
return;
|
|
571
585
|
}
|
|
572
586
|
});
|
|
573
587
|
let v = [], F = {};
|
|
574
588
|
m.forEach((d) => {
|
|
575
|
-
let f =
|
|
576
|
-
if (
|
|
577
|
-
if (
|
|
589
|
+
let f = q(d), V = O[f];
|
|
590
|
+
if (V !== void 0) {
|
|
591
|
+
if (V.item !== d) {
|
|
578
592
|
F[f] = !0;
|
|
579
|
-
let
|
|
593
|
+
let je = X(d), xe = b(je), oe = {
|
|
580
594
|
key: f,
|
|
581
595
|
item: d,
|
|
582
|
-
element:
|
|
596
|
+
element: xe
|
|
583
597
|
};
|
|
584
|
-
v.push(
|
|
598
|
+
v.push(oe), O[f] = oe;
|
|
585
599
|
return;
|
|
586
600
|
}
|
|
587
|
-
v.push(
|
|
601
|
+
v.push(V);
|
|
588
602
|
return;
|
|
589
603
|
}
|
|
590
|
-
let
|
|
604
|
+
let Me = X(d), Ie = b(Me), ie = {
|
|
591
605
|
key: f,
|
|
592
606
|
item: d,
|
|
593
|
-
element:
|
|
607
|
+
element: Ie
|
|
594
608
|
};
|
|
595
|
-
v.push(
|
|
609
|
+
v.push(ie), O[f] = ie;
|
|
596
610
|
});
|
|
597
611
|
let $ = {
|
|
598
|
-
contents:
|
|
612
|
+
contents: U.nextSibling
|
|
599
613
|
};
|
|
600
614
|
v.forEach((d) => {
|
|
601
615
|
let f = $.contents;
|
|
@@ -611,59 +625,59 @@ function b(e) {
|
|
|
611
625
|
$.contents = f.nextSibling;
|
|
612
626
|
return;
|
|
613
627
|
}
|
|
614
|
-
|
|
628
|
+
Z(F[d.key], !1) ? (L(f), i.replaceChild(d.element, f), $.contents = d.element.nextSibling) : (i.insertBefore(d.element, f), $.contents = d.element.nextSibling);
|
|
615
629
|
});
|
|
616
|
-
},
|
|
617
|
-
return
|
|
618
|
-
let m =
|
|
630
|
+
}, B = document.createDocumentFragment();
|
|
631
|
+
return B.appendChild(U), s.peek(ue).forEach((i) => {
|
|
632
|
+
let m = q(i), g = X(i), E = b(g), v = {
|
|
619
633
|
key: m,
|
|
620
634
|
item: i,
|
|
621
635
|
element: E
|
|
622
636
|
};
|
|
623
|
-
O[m] = v,
|
|
624
|
-
}),
|
|
637
|
+
O[m] = v, B.appendChild(E);
|
|
638
|
+
}), B.appendChild(D), N(H, () => {
|
|
625
639
|
let i = w.run(() => {
|
|
626
|
-
|
|
640
|
+
Ne();
|
|
627
641
|
}, void 0);
|
|
628
|
-
|
|
629
|
-
}),
|
|
642
|
+
M(H, i);
|
|
643
|
+
}), B;
|
|
630
644
|
}
|
|
631
645
|
}
|
|
632
|
-
let
|
|
646
|
+
let $t = {
|
|
633
647
|
disposeElement: L,
|
|
634
648
|
render: b
|
|
635
649
|
};
|
|
636
|
-
function
|
|
650
|
+
function Ct(e) {
|
|
637
651
|
return {
|
|
638
652
|
TAG: "Text",
|
|
639
653
|
_0: e
|
|
640
654
|
};
|
|
641
655
|
}
|
|
642
|
-
function
|
|
656
|
+
function Nt(e) {
|
|
643
657
|
return {
|
|
644
658
|
TAG: "SignalText",
|
|
645
659
|
_0: S.make(e, void 0)
|
|
646
660
|
};
|
|
647
661
|
}
|
|
648
|
-
function
|
|
662
|
+
function Mt(e) {
|
|
649
663
|
return {
|
|
650
664
|
TAG: "Fragment",
|
|
651
665
|
_0: e
|
|
652
666
|
};
|
|
653
667
|
}
|
|
654
|
-
function
|
|
668
|
+
function ne(e) {
|
|
655
669
|
return {
|
|
656
670
|
TAG: "SignalFragment",
|
|
657
671
|
_0: e
|
|
658
672
|
};
|
|
659
673
|
}
|
|
660
|
-
function
|
|
674
|
+
function It(e, t) {
|
|
661
675
|
return {
|
|
662
676
|
TAG: "SignalFragment",
|
|
663
677
|
_0: S.make(() => s.get(e).map(t), void 0)
|
|
664
678
|
};
|
|
665
679
|
}
|
|
666
|
-
function
|
|
680
|
+
function jt(e, t, n) {
|
|
667
681
|
return {
|
|
668
682
|
TAG: "KeyedList",
|
|
669
683
|
signal: e,
|
|
@@ -681,10 +695,10 @@ function _(e, t, n, r, l) {
|
|
|
681
695
|
children: o
|
|
682
696
|
};
|
|
683
697
|
}
|
|
684
|
-
function
|
|
698
|
+
function xt(e, t, n, r) {
|
|
685
699
|
return _("div", e, t, n);
|
|
686
700
|
}
|
|
687
|
-
function
|
|
701
|
+
function Pt(e, t, n, r) {
|
|
688
702
|
return _("span", e, t, n);
|
|
689
703
|
}
|
|
690
704
|
function Rt(e, t, n, r) {
|
|
@@ -699,82 +713,82 @@ function Ft(e, t, n, r) {
|
|
|
699
713
|
function Lt(e, t, n, r) {
|
|
700
714
|
return _("h2", e, t, n);
|
|
701
715
|
}
|
|
702
|
-
function
|
|
716
|
+
function Gt(e, t, n, r) {
|
|
703
717
|
return _("h3", e, t, n);
|
|
704
718
|
}
|
|
705
|
-
function
|
|
719
|
+
function Bt(e, t, n, r) {
|
|
706
720
|
return _("p", e, t, n);
|
|
707
721
|
}
|
|
708
|
-
function
|
|
722
|
+
function Vt(e, t, n, r) {
|
|
709
723
|
return _("ul", e, t, n);
|
|
710
724
|
}
|
|
711
|
-
function
|
|
725
|
+
function zt(e, t, n, r) {
|
|
712
726
|
return _("li", e, t, n);
|
|
713
727
|
}
|
|
714
|
-
function
|
|
728
|
+
function ke(e, t, n, r) {
|
|
715
729
|
return _("a", e, t, n);
|
|
716
730
|
}
|
|
717
|
-
function
|
|
731
|
+
function Oe(e, t) {
|
|
718
732
|
let n = b(e);
|
|
719
733
|
t.appendChild(n);
|
|
720
734
|
}
|
|
721
|
-
function
|
|
735
|
+
function Wt(e, t) {
|
|
722
736
|
let n = document.getElementById(t);
|
|
723
737
|
if (n == null) {
|
|
724
738
|
console.error("Container element not found: " + t);
|
|
725
739
|
return;
|
|
726
740
|
} else
|
|
727
|
-
return
|
|
741
|
+
return Oe(e, n);
|
|
728
742
|
}
|
|
729
|
-
let
|
|
730
|
-
const
|
|
743
|
+
let Te = ye, Kt = be, Xt = we;
|
|
744
|
+
const qt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
731
745
|
__proto__: null,
|
|
732
|
-
Attributes:
|
|
733
|
-
DOM:
|
|
734
|
-
Reactivity:
|
|
735
|
-
Render:
|
|
736
|
-
a:
|
|
737
|
-
attr:
|
|
746
|
+
Attributes: At,
|
|
747
|
+
DOM: kt,
|
|
748
|
+
Reactivity: Tt,
|
|
749
|
+
Render: $t,
|
|
750
|
+
a: ke,
|
|
751
|
+
attr: Te,
|
|
738
752
|
button: Rt,
|
|
739
|
-
computedAttr:
|
|
740
|
-
div:
|
|
753
|
+
computedAttr: Xt,
|
|
754
|
+
div: xt,
|
|
741
755
|
element: _,
|
|
742
|
-
fragment:
|
|
756
|
+
fragment: Mt,
|
|
743
757
|
h1: Ft,
|
|
744
758
|
h2: Lt,
|
|
745
|
-
h3:
|
|
759
|
+
h3: Gt,
|
|
746
760
|
input: Dt,
|
|
747
|
-
keyedList:
|
|
748
|
-
li:
|
|
749
|
-
list:
|
|
750
|
-
mount:
|
|
751
|
-
mountById:
|
|
752
|
-
p:
|
|
753
|
-
signalAttr:
|
|
754
|
-
signalFragment:
|
|
755
|
-
span:
|
|
756
|
-
text:
|
|
757
|
-
textSignal:
|
|
758
|
-
ul:
|
|
761
|
+
keyedList: jt,
|
|
762
|
+
li: zt,
|
|
763
|
+
list: It,
|
|
764
|
+
mount: Oe,
|
|
765
|
+
mountById: Wt,
|
|
766
|
+
p: Bt,
|
|
767
|
+
signalAttr: Kt,
|
|
768
|
+
signalFragment: ne,
|
|
769
|
+
span: Pt,
|
|
770
|
+
text: Ct,
|
|
771
|
+
textSignal: Nt,
|
|
772
|
+
ul: Vt
|
|
759
773
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
760
774
|
let T = s.make({
|
|
761
775
|
pathname: "/",
|
|
762
776
|
search: "",
|
|
763
777
|
hash: ""
|
|
764
778
|
}, void 0, void 0);
|
|
765
|
-
function
|
|
779
|
+
function Q() {
|
|
766
780
|
return {
|
|
767
781
|
pathname: window.location.pathname,
|
|
768
782
|
search: window.location.search,
|
|
769
783
|
hash: window.location.hash
|
|
770
784
|
};
|
|
771
785
|
}
|
|
772
|
-
function
|
|
773
|
-
s.set(T,
|
|
774
|
-
let e = (t) => s.set(T,
|
|
786
|
+
function Ht() {
|
|
787
|
+
s.set(T, Q());
|
|
788
|
+
let e = (t) => s.set(T, Q());
|
|
775
789
|
window.addEventListener("popstate", e);
|
|
776
790
|
}
|
|
777
|
-
function
|
|
791
|
+
function Ae(e, t, n, r) {
|
|
778
792
|
let l = t !== void 0 ? t : "", u = n !== void 0 ? n : "", a = {
|
|
779
793
|
pathname: e,
|
|
780
794
|
search: l,
|
|
@@ -782,7 +796,7 @@ function Te(e, t, n, r) {
|
|
|
782
796
|
}, o = e + l + u, c = {};
|
|
783
797
|
window.history.pushState(c, "", o), s.set(T, a);
|
|
784
798
|
}
|
|
785
|
-
function
|
|
799
|
+
function Ut(e, t, n, r) {
|
|
786
800
|
let l = t !== void 0 ? t : "", u = n !== void 0 ? n : "", a = {
|
|
787
801
|
pathname: e,
|
|
788
802
|
search: l,
|
|
@@ -790,73 +804,73 @@ function Ht(e, t, n, r) {
|
|
|
790
804
|
}, o = e + l + u, c = {};
|
|
791
805
|
window.history.replaceState(c, "", o), s.set(T, a);
|
|
792
806
|
}
|
|
793
|
-
function
|
|
794
|
-
return
|
|
795
|
-
let n = s.get(T), r =
|
|
807
|
+
function Jt(e, t) {
|
|
808
|
+
return ne(S.make(() => {
|
|
809
|
+
let n = s.get(T), r = te(e, n.pathname);
|
|
796
810
|
return typeof r != "object" ? [] : [t(r._0)];
|
|
797
811
|
}, void 0));
|
|
798
812
|
}
|
|
799
|
-
function
|
|
800
|
-
return
|
|
813
|
+
function Qt(e) {
|
|
814
|
+
return ne(S.make(() => {
|
|
801
815
|
let t = s.get(T), n = Le(e, (r) => {
|
|
802
|
-
let l =
|
|
816
|
+
let l = te(r.pattern, t.pathname);
|
|
803
817
|
if (typeof l == "object")
|
|
804
818
|
return r.render(l._0);
|
|
805
819
|
});
|
|
806
820
|
return n !== void 0 ? [n] : [];
|
|
807
821
|
}, void 0));
|
|
808
822
|
}
|
|
809
|
-
function
|
|
823
|
+
function Yt(e, t, n, r) {
|
|
810
824
|
let l = t !== void 0 ? t : [], u = n !== void 0 ? n : [], a = (o) => {
|
|
811
|
-
o.preventDefault(),
|
|
825
|
+
o.preventDefault(), Ae(e, void 0, void 0);
|
|
812
826
|
};
|
|
813
|
-
return
|
|
827
|
+
return ke(l.concat([Te("href", e)]), [[
|
|
814
828
|
"click",
|
|
815
829
|
a
|
|
816
830
|
]], u);
|
|
817
831
|
}
|
|
818
|
-
let
|
|
819
|
-
const
|
|
832
|
+
let Zt, en;
|
|
833
|
+
const tn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
|
|
820
834
|
__proto__: null,
|
|
821
|
-
Component:
|
|
822
|
-
Route:
|
|
823
|
-
getCurrentLocation:
|
|
824
|
-
init:
|
|
825
|
-
link:
|
|
835
|
+
Component: Zt,
|
|
836
|
+
Route: en,
|
|
837
|
+
getCurrentLocation: Q,
|
|
838
|
+
init: Ht,
|
|
839
|
+
link: Yt,
|
|
826
840
|
location: T,
|
|
827
|
-
push:
|
|
828
|
-
replace:
|
|
829
|
-
route:
|
|
830
|
-
routes:
|
|
841
|
+
push: Ae,
|
|
842
|
+
replace: Ut,
|
|
843
|
+
route: Jt,
|
|
844
|
+
routes: Qt
|
|
831
845
|
}, Symbol.toStringTag, { value: "Module" }));
|
|
832
|
-
let
|
|
833
|
-
Id:
|
|
834
|
-
Scheduler:
|
|
835
|
-
make:
|
|
836
|
-
get:
|
|
837
|
-
peek:
|
|
838
|
-
set:
|
|
839
|
-
update:
|
|
840
|
-
batch:
|
|
841
|
-
untrack:
|
|
842
|
-
},
|
|
843
|
-
Id:
|
|
844
|
-
Signal:
|
|
845
|
-
Observer:
|
|
846
|
-
Scheduler:
|
|
847
|
-
make:
|
|
848
|
-
dispose:
|
|
849
|
-
},
|
|
850
|
-
Id:
|
|
851
|
-
Observer:
|
|
852
|
-
Scheduler:
|
|
853
|
-
run:
|
|
854
|
-
},
|
|
846
|
+
let nn = s.Id, rn = s.Scheduler, ln = s.make, un = s.get, on = s.peek, cn = s.set, dn = s.update, sn = s.batch, an = s.untrack, wn = {
|
|
847
|
+
Id: nn,
|
|
848
|
+
Scheduler: rn,
|
|
849
|
+
make: ln,
|
|
850
|
+
get: un,
|
|
851
|
+
peek: on,
|
|
852
|
+
set: cn,
|
|
853
|
+
update: dn,
|
|
854
|
+
batch: sn,
|
|
855
|
+
untrack: an
|
|
856
|
+
}, fn = S.Id, pn = S.Signal, mn = S.Observer, hn = S.Scheduler, _n = S.make, gn = S.dispose, kn = {
|
|
857
|
+
Id: fn,
|
|
858
|
+
Signal: pn,
|
|
859
|
+
Observer: mn,
|
|
860
|
+
Scheduler: hn,
|
|
861
|
+
make: _n,
|
|
862
|
+
dispose: gn
|
|
863
|
+
}, Sn = w.Id, En = w.Observer, vn = w.Scheduler, yn = w.run, On = {
|
|
864
|
+
Id: Sn,
|
|
865
|
+
Observer: En,
|
|
866
|
+
Scheduler: vn,
|
|
867
|
+
run: yn
|
|
868
|
+
}, Tn = qt, An = bt, $n = tn;
|
|
855
869
|
export {
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
870
|
+
Tn as Component,
|
|
871
|
+
kn as Computed,
|
|
872
|
+
On as Effect,
|
|
873
|
+
An as Route,
|
|
874
|
+
$n as Router,
|
|
875
|
+
wn as Signal
|
|
862
876
|
};
|