@esportsplus/template 0.15.20 → 0.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (45) hide show
  1. package/build/attributes.js +27 -23
  2. package/build/constants.d.ts +14 -3
  3. package/build/constants.js +15 -3
  4. package/build/event.js +7 -7
  5. package/build/html/cache.d.ts +2 -2
  6. package/build/html/cache.js +24 -16
  7. package/build/html/hydrate.d.ts +2 -6
  8. package/build/html/hydrate.js +29 -53
  9. package/build/html/index.d.ts +2106 -5
  10. package/build/html/index.js +12 -4
  11. package/build/render.d.ts +1 -2
  12. package/build/render.js +6 -10
  13. package/build/slot/cleanup.d.ts +4 -0
  14. package/build/slot/cleanup.js +51 -0
  15. package/build/slot/effect.d.ts +3 -0
  16. package/build/slot/effect.js +51 -0
  17. package/build/slot/index.d.ts +3 -0
  18. package/build/slot/index.js +15 -0
  19. package/build/slot/reactive.d.ts +3 -0
  20. package/build/slot/reactive.js +117 -0
  21. package/build/slot/render.d.ts +2 -0
  22. package/build/slot/render.js +58 -0
  23. package/build/svg.d.ts +1 -2
  24. package/build/types.d.ts +25 -21
  25. package/build/utilities.d.ts +3 -3
  26. package/build/utilities.js +12 -12
  27. package/package.json +2 -2
  28. package/src/attributes.ts +30 -28
  29. package/src/constants.ts +38 -4
  30. package/src/event.ts +8 -8
  31. package/src/html/cache.ts +28 -18
  32. package/src/html/hydrate.ts +38 -68
  33. package/src/html/index.ts +16 -8
  34. package/src/render.ts +8 -12
  35. package/src/slot/cleanup.ts +74 -0
  36. package/src/slot/effect.ts +73 -0
  37. package/src/slot/index.ts +23 -0
  38. package/src/slot/reactive.ts +167 -0
  39. package/src/slot/render.ts +81 -0
  40. package/src/svg.ts +1 -2
  41. package/src/types.ts +30 -20
  42. package/src/utilities.ts +15 -13
  43. package/build/slot.d.ts +0 -21
  44. package/build/slot.js +0 -200
  45. package/src/slot.ts +0 -287
package/build/html/index.d.ts CHANGED
@@ -1,9 +1,2110 @@
1
1
  import { ReactiveArray } from '@esportsplus/reactivity';
2
- import { RenderableReactive, RenderableTemplate } from '../types.js';
3
- import hydrate from './hydrate.js';
2
+ import { RENDERABLE } from '../constants.js';
3
+ import { RenderableReactive, RenderableTemplate, RenderableValues } from '../types.js';
4
4
  declare const html: {
5
- <T>(literals: TemplateStringsArray, ...values: RenderableTemplate<T>["values"]): RenderableTemplate<T>;
6
- reactive<T>(array: ReactiveArray<T>, template: RenderableReactive<T>["template"]): RenderableReactive<T>;
5
+ (literals: TemplateStringsArray, ...values: RenderableValues[]): RenderableTemplate;
6
+ reactive<T>(array: ReactiveArray<T[]>, template: RenderableReactive["template"]): {
7
+ [RENDERABLE]: number;
8
+ array: {
9
+ [x: number]: import("@esportsplus/reactivity").Infer<T>;
10
+ length: number;
11
+ toString: () => string;
12
+ toLocaleString: {
13
+ (): string;
14
+ (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
15
+ };
16
+ pop: () => import("@esportsplus/reactivity").Infer<T> | undefined;
17
+ push: (...items: import("@esportsplus/reactivity").Infer<T>[]) => number;
18
+ concat: {
19
+ (...items: ConcatArray<import("@esportsplus/reactivity").Infer<T>>[]): import("@esportsplus/reactivity").Infer<T>[];
20
+ (...items: (import("@esportsplus/reactivity").Infer<T> | ConcatArray<import("@esportsplus/reactivity").Infer<T>>)[]): import("@esportsplus/reactivity").Infer<T>[];
21
+ };
22
+ join: (separator?: string) => string;
23
+ reverse: () => import("@esportsplus/reactivity").Infer<T>[];
24
+ shift: () => import("@esportsplus/reactivity").Infer<T> | undefined;
25
+ slice: (start?: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[];
26
+ sort: (compareFn?: ((a: import("@esportsplus/reactivity").Infer<T>, b: import("@esportsplus/reactivity").Infer<T>) => number) | undefined) => import("@esportsplus/reactivity").Infer<T>[] & {
27
+ clear: () => void;
28
+ dispose: () => void;
29
+ dispatch: <K extends keyof {
30
+ clear: undefined;
31
+ pop: {
32
+ item: T_1[number];
33
+ };
34
+ push: {
35
+ items: T_1[number][];
36
+ };
37
+ reverse: undefined;
38
+ set: {
39
+ index: number;
40
+ item: T_1[number];
41
+ };
42
+ shift: {
43
+ item: T_1[number];
44
+ };
45
+ sort: undefined;
46
+ splice: {
47
+ deleteCount: number;
48
+ items: T_1[number][];
49
+ start: number;
50
+ };
51
+ unshift: {
52
+ items: T_1[number][];
53
+ };
54
+ }, V>(event: K, value?: V | undefined) => void;
55
+ map: <R>(fn: (this: {
56
+ [x: number]: import("@esportsplus/reactivity").Infer<T>;
57
+ length: number;
58
+ toString: () => string;
59
+ toLocaleString: {
60
+ (): string;
61
+ (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
62
+ };
63
+ pop: () => import("@esportsplus/reactivity").Infer<T> | undefined;
64
+ push: (...items: import("@esportsplus/reactivity").Infer<T>[]) => number;
65
+ concat: {
66
+ (...items: ConcatArray<import("@esportsplus/reactivity").Infer<T>>[]): import("@esportsplus/reactivity").Infer<T>[];
67
+ (...items: (import("@esportsplus/reactivity").Infer<T> | ConcatArray<import("@esportsplus/reactivity").Infer<T>>)[]): import("@esportsplus/reactivity").Infer<T>[];
68
+ };
69
+ join: (separator?: string) => string;
70
+ reverse: () => import("@esportsplus/reactivity").Infer<T>[];
71
+ shift: () => import("@esportsplus/reactivity").Infer<T> | undefined;
72
+ slice: (start?: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[];
73
+ sort: any;
74
+ splice: {
75
+ (start: number, deleteCount?: number): import("@esportsplus/reactivity").Infer<T>[];
76
+ (start: number, deleteCount: number, ...items: import("@esportsplus/reactivity").Infer<T>[]): import("@esportsplus/reactivity").Infer<T>[];
77
+ };
78
+ unshift: (...items: import("@esportsplus/reactivity").Infer<T>[]) => number;
79
+ indexOf: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => number;
80
+ lastIndexOf: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => number;
81
+ every: {
82
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): this is S[];
83
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): boolean;
84
+ };
85
+ some: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => boolean;
86
+ forEach: (callbackfn: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => void, thisArg?: any) => void;
87
+ map: (<U>(callbackfn: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, thisArg?: any) => U[]) & any;
88
+ filter: {
89
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S[];
90
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T>[];
91
+ };
92
+ reduce: {
93
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
94
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>, initialValue: import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
95
+ <U>(callbackfn: (previousValue: U, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, initialValue: U): U;
96
+ };
97
+ reduceRight: {
98
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
99
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>, initialValue: import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
100
+ <U>(callbackfn: (previousValue: U, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, initialValue: U): U;
101
+ };
102
+ find: {
103
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S | undefined;
104
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T> | undefined;
105
+ };
106
+ findIndex: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => number;
107
+ fill: (value: import("@esportsplus/reactivity").Infer<T>, start?: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[] & any;
108
+ copyWithin: (target: number, start: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[] & any;
109
+ entries: () => ArrayIterator<[number, import("@esportsplus/reactivity").Infer<T>]>;
110
+ keys: () => ArrayIterator<number>;
111
+ values: () => ArrayIterator<import("@esportsplus/reactivity").Infer<T>>;
112
+ includes: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => boolean;
113
+ flatMap: <U, This = undefined>(callback: (this: This, value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U | readonly U[], thisArg?: This | undefined) => U[];
114
+ flat: <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
115
+ at: (index: number) => import("@esportsplus/reactivity").Infer<T> | undefined;
116
+ findLast: {
117
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S | undefined;
118
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T> | undefined;
119
+ };
120
+ findLastIndex: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => number;
121
+ toReversed: () => import("@esportsplus/reactivity").Infer<T>[];
122
+ toSorted: (compareFn?: ((a: import("@esportsplus/reactivity").Infer<T>, b: import("@esportsplus/reactivity").Infer<T>) => number) | undefined) => import("@esportsplus/reactivity").Infer<T>[];
123
+ toSpliced: {
124
+ (start: number, deleteCount: number, ...items: import("@esportsplus/reactivity").Infer<T>[]): import("@esportsplus/reactivity").Infer<T>[];
125
+ (start: number, deleteCount?: number): import("@esportsplus/reactivity").Infer<T>[];
126
+ };
127
+ with: (index: number, value: import("@esportsplus/reactivity").Infer<T>) => import("@esportsplus/reactivity").Infer<T>[];
128
+ [Symbol.iterator]: () => ArrayIterator<import("@esportsplus/reactivity").Infer<T>>;
129
+ readonly [Symbol.unscopables]: {
130
+ [x: number]: boolean | undefined;
131
+ length?: boolean | undefined;
132
+ toString?: boolean | undefined;
133
+ toLocaleString?: boolean | undefined;
134
+ pop?: boolean | undefined;
135
+ push?: boolean | undefined;
136
+ concat?: boolean | undefined;
137
+ join?: boolean | undefined;
138
+ reverse?: boolean | undefined;
139
+ shift?: boolean | undefined;
140
+ slice?: boolean | undefined;
141
+ sort?: boolean | undefined;
142
+ splice?: boolean | undefined;
143
+ unshift?: boolean | undefined;
144
+ indexOf?: boolean | undefined;
145
+ lastIndexOf?: boolean | undefined;
146
+ every?: boolean | undefined;
147
+ some?: boolean | undefined;
148
+ forEach?: boolean | undefined;
149
+ map?: boolean | undefined;
150
+ filter?: boolean | undefined;
151
+ reduce?: boolean | undefined;
152
+ reduceRight?: boolean | undefined;
153
+ find?: boolean | undefined;
154
+ findIndex?: boolean | undefined;
155
+ fill?: boolean | undefined;
156
+ copyWithin?: boolean | undefined;
157
+ entries?: boolean | undefined;
158
+ keys?: boolean | undefined;
159
+ values?: boolean | undefined;
160
+ includes?: boolean | undefined;
161
+ flatMap?: boolean | undefined;
162
+ flat?: boolean | undefined;
163
+ at?: boolean | undefined;
164
+ findLast?: boolean | undefined;
165
+ findLastIndex?: boolean | undefined;
166
+ toReversed?: boolean | undefined;
167
+ toSorted?: boolean | undefined;
168
+ toSpliced?: boolean | undefined;
169
+ with?: boolean | undefined;
170
+ [Symbol.iterator]?: boolean | undefined;
171
+ readonly [Symbol.unscopables]?: boolean | undefined;
172
+ };
173
+ clear: () => void;
174
+ dispose: () => void;
175
+ dispatch: <K extends keyof {
176
+ clear: undefined;
177
+ pop: {
178
+ item: T_1[number];
179
+ };
180
+ push: {
181
+ items: T_1[number][];
182
+ };
183
+ reverse: undefined;
184
+ set: {
185
+ index: number;
186
+ item: T_1[number];
187
+ };
188
+ shift: {
189
+ item: T_1[number];
190
+ };
191
+ sort: undefined;
192
+ splice: {
193
+ deleteCount: number;
194
+ items: T_1[number][];
195
+ start: number;
196
+ };
197
+ unshift: {
198
+ items: T_1[number][];
199
+ };
200
+ }, V>(event: K, value?: V | undefined) => void;
201
+ on: <K extends keyof {
202
+ clear: undefined;
203
+ pop: {
204
+ item: T_1[number];
205
+ };
206
+ push: {
207
+ items: T_1[number][];
208
+ };
209
+ reverse: undefined;
210
+ set: {
211
+ index: number;
212
+ item: T_1[number];
213
+ };
214
+ shift: {
215
+ item: T_1[number];
216
+ };
217
+ sort: undefined;
218
+ splice: {
219
+ deleteCount: number;
220
+ items: T_1[number][];
221
+ start: number;
222
+ };
223
+ unshift: {
224
+ items: T_1[number][];
225
+ };
226
+ }>(event: K, listener: {
227
+ (value: {
228
+ clear: undefined;
229
+ pop: {
230
+ item: T;
231
+ };
232
+ push: {
233
+ items: T[];
234
+ };
235
+ reverse: undefined;
236
+ set: {
237
+ index: number;
238
+ item: T;
239
+ };
240
+ shift: {
241
+ item: T;
242
+ };
243
+ sort: undefined;
244
+ splice: {
245
+ deleteCount: number;
246
+ items: T[];
247
+ start: number;
248
+ };
249
+ unshift: {
250
+ items: T[];
251
+ };
252
+ }[K]): void;
253
+ once?: boolean;
254
+ }) => void;
255
+ once: <K extends keyof {
256
+ clear: undefined;
257
+ pop: {
258
+ item: T_1[number];
259
+ };
260
+ push: {
261
+ items: T_1[number][];
262
+ };
263
+ reverse: undefined;
264
+ set: {
265
+ index: number;
266
+ item: T_1[number];
267
+ };
268
+ shift: {
269
+ item: T_1[number];
270
+ };
271
+ sort: undefined;
272
+ splice: {
273
+ deleteCount: number;
274
+ items: T_1[number][];
275
+ start: number;
276
+ };
277
+ unshift: {
278
+ items: T_1[number][];
279
+ };
280
+ }>(event: K, listener: {
281
+ (value: {
282
+ clear: undefined;
283
+ pop: {
284
+ item: T;
285
+ };
286
+ push: {
287
+ items: T[];
288
+ };
289
+ reverse: undefined;
290
+ set: {
291
+ index: number;
292
+ item: T;
293
+ };
294
+ shift: {
295
+ item: T;
296
+ };
297
+ sort: undefined;
298
+ splice: {
299
+ deleteCount: number;
300
+ items: T[];
301
+ start: number;
302
+ };
303
+ unshift: {
304
+ items: T[];
305
+ };
306
+ }[K]): void;
307
+ once?: boolean;
308
+ }) => void;
309
+ }, value: T, i: number) => R) => R[];
310
+ on: <K extends keyof {
311
+ clear: undefined;
312
+ pop: {
313
+ item: T_1[number];
314
+ };
315
+ push: {
316
+ items: T_1[number][];
317
+ };
318
+ reverse: undefined;
319
+ set: {
320
+ index: number;
321
+ item: T_1[number];
322
+ };
323
+ shift: {
324
+ item: T_1[number];
325
+ };
326
+ sort: undefined;
327
+ splice: {
328
+ deleteCount: number;
329
+ items: T_1[number][];
330
+ start: number;
331
+ };
332
+ unshift: {
333
+ items: T_1[number][];
334
+ };
335
+ }>(event: K, listener: {
336
+ (value: {
337
+ clear: undefined;
338
+ pop: {
339
+ item: T;
340
+ };
341
+ push: {
342
+ items: T[];
343
+ };
344
+ reverse: undefined;
345
+ set: {
346
+ index: number;
347
+ item: T;
348
+ };
349
+ shift: {
350
+ item: T;
351
+ };
352
+ sort: undefined;
353
+ splice: {
354
+ deleteCount: number;
355
+ items: T[];
356
+ start: number;
357
+ };
358
+ unshift: {
359
+ items: T[];
360
+ };
361
+ }[K]): void;
362
+ once?: boolean;
363
+ }) => void;
364
+ once: <K extends keyof {
365
+ clear: undefined;
366
+ pop: {
367
+ item: T_1[number];
368
+ };
369
+ push: {
370
+ items: T_1[number][];
371
+ };
372
+ reverse: undefined;
373
+ set: {
374
+ index: number;
375
+ item: T_1[number];
376
+ };
377
+ shift: {
378
+ item: T_1[number];
379
+ };
380
+ sort: undefined;
381
+ splice: {
382
+ deleteCount: number;
383
+ items: T_1[number][];
384
+ start: number;
385
+ };
386
+ unshift: {
387
+ items: T_1[number][];
388
+ };
389
+ }>(event: K, listener: {
390
+ (value: {
391
+ clear: undefined;
392
+ pop: {
393
+ item: T;
394
+ };
395
+ push: {
396
+ items: T[];
397
+ };
398
+ reverse: undefined;
399
+ set: {
400
+ index: number;
401
+ item: T;
402
+ };
403
+ shift: {
404
+ item: T;
405
+ };
406
+ sort: undefined;
407
+ splice: {
408
+ deleteCount: number;
409
+ items: T[];
410
+ start: number;
411
+ };
412
+ unshift: {
413
+ items: T[];
414
+ };
415
+ }[K]): void;
416
+ once?: boolean;
417
+ }) => void;
418
+ };
419
+ splice: {
420
+ (start: number, deleteCount?: number): import("@esportsplus/reactivity").Infer<T>[];
421
+ (start: number, deleteCount: number, ...items: import("@esportsplus/reactivity").Infer<T>[]): import("@esportsplus/reactivity").Infer<T>[];
422
+ };
423
+ unshift: (...items: import("@esportsplus/reactivity").Infer<T>[]) => number;
424
+ indexOf: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => number;
425
+ lastIndexOf: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => number;
426
+ every: {
427
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): this is S[];
428
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): boolean;
429
+ };
430
+ some: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => boolean;
431
+ forEach: (callbackfn: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => void, thisArg?: any) => void;
432
+ map: (<U>(callbackfn: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, thisArg?: any) => U[]) & (<R>(fn: (this: {
433
+ [x: number]: import("@esportsplus/reactivity").Infer<T>;
434
+ length: number;
435
+ toString: () => string;
436
+ toLocaleString: {
437
+ (): string;
438
+ (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
439
+ };
440
+ pop: () => import("@esportsplus/reactivity").Infer<T> | undefined;
441
+ push: (...items: import("@esportsplus/reactivity").Infer<T>[]) => number;
442
+ concat: {
443
+ (...items: ConcatArray<import("@esportsplus/reactivity").Infer<T>>[]): import("@esportsplus/reactivity").Infer<T>[];
444
+ (...items: (import("@esportsplus/reactivity").Infer<T> | ConcatArray<import("@esportsplus/reactivity").Infer<T>>)[]): import("@esportsplus/reactivity").Infer<T>[];
445
+ };
446
+ join: (separator?: string) => string;
447
+ reverse: () => import("@esportsplus/reactivity").Infer<T>[];
448
+ shift: () => import("@esportsplus/reactivity").Infer<T> | undefined;
449
+ slice: (start?: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[];
450
+ sort: (compareFn?: ((a: import("@esportsplus/reactivity").Infer<T>, b: import("@esportsplus/reactivity").Infer<T>) => number) | undefined) => import("@esportsplus/reactivity").Infer<T>[] & {
451
+ clear: () => void;
452
+ dispose: () => void;
453
+ dispatch: <K extends keyof {
454
+ clear: undefined;
455
+ pop: {
456
+ item: T_1[number];
457
+ };
458
+ push: {
459
+ items: T_1[number][];
460
+ };
461
+ reverse: undefined;
462
+ set: {
463
+ index: number;
464
+ item: T_1[number];
465
+ };
466
+ shift: {
467
+ item: T_1[number];
468
+ };
469
+ sort: undefined;
470
+ splice: {
471
+ deleteCount: number;
472
+ items: T_1[number][];
473
+ start: number;
474
+ };
475
+ unshift: {
476
+ items: T_1[number][];
477
+ };
478
+ }, V>(event: K, value?: V | undefined) => void;
479
+ map: any;
480
+ on: <K extends keyof {
481
+ clear: undefined;
482
+ pop: {
483
+ item: T_1[number];
484
+ };
485
+ push: {
486
+ items: T_1[number][];
487
+ };
488
+ reverse: undefined;
489
+ set: {
490
+ index: number;
491
+ item: T_1[number];
492
+ };
493
+ shift: {
494
+ item: T_1[number];
495
+ };
496
+ sort: undefined;
497
+ splice: {
498
+ deleteCount: number;
499
+ items: T_1[number][];
500
+ start: number;
501
+ };
502
+ unshift: {
503
+ items: T_1[number][];
504
+ };
505
+ }>(event: K, listener: {
506
+ (value: {
507
+ clear: undefined;
508
+ pop: {
509
+ item: T;
510
+ };
511
+ push: {
512
+ items: T[];
513
+ };
514
+ reverse: undefined;
515
+ set: {
516
+ index: number;
517
+ item: T;
518
+ };
519
+ shift: {
520
+ item: T;
521
+ };
522
+ sort: undefined;
523
+ splice: {
524
+ deleteCount: number;
525
+ items: T[];
526
+ start: number;
527
+ };
528
+ unshift: {
529
+ items: T[];
530
+ };
531
+ }[K]): void;
532
+ once?: boolean;
533
+ }) => void;
534
+ once: <K extends keyof {
535
+ clear: undefined;
536
+ pop: {
537
+ item: T_1[number];
538
+ };
539
+ push: {
540
+ items: T_1[number][];
541
+ };
542
+ reverse: undefined;
543
+ set: {
544
+ index: number;
545
+ item: T_1[number];
546
+ };
547
+ shift: {
548
+ item: T_1[number];
549
+ };
550
+ sort: undefined;
551
+ splice: {
552
+ deleteCount: number;
553
+ items: T_1[number][];
554
+ start: number;
555
+ };
556
+ unshift: {
557
+ items: T_1[number][];
558
+ };
559
+ }>(event: K, listener: {
560
+ (value: {
561
+ clear: undefined;
562
+ pop: {
563
+ item: T;
564
+ };
565
+ push: {
566
+ items: T[];
567
+ };
568
+ reverse: undefined;
569
+ set: {
570
+ index: number;
571
+ item: T;
572
+ };
573
+ shift: {
574
+ item: T;
575
+ };
576
+ sort: undefined;
577
+ splice: {
578
+ deleteCount: number;
579
+ items: T[];
580
+ start: number;
581
+ };
582
+ unshift: {
583
+ items: T[];
584
+ };
585
+ }[K]): void;
586
+ once?: boolean;
587
+ }) => void;
588
+ };
589
+ splice: {
590
+ (start: number, deleteCount?: number): import("@esportsplus/reactivity").Infer<T>[];
591
+ (start: number, deleteCount: number, ...items: import("@esportsplus/reactivity").Infer<T>[]): import("@esportsplus/reactivity").Infer<T>[];
592
+ };
593
+ unshift: (...items: import("@esportsplus/reactivity").Infer<T>[]) => number;
594
+ indexOf: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => number;
595
+ lastIndexOf: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => number;
596
+ every: {
597
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): this is S[];
598
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): boolean;
599
+ };
600
+ some: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => boolean;
601
+ forEach: (callbackfn: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => void, thisArg?: any) => void;
602
+ map: (<U>(callbackfn: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, thisArg?: any) => U[]) & any;
603
+ filter: {
604
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S[];
605
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T>[];
606
+ };
607
+ reduce: {
608
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
609
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>, initialValue: import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
610
+ <U>(callbackfn: (previousValue: U, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, initialValue: U): U;
611
+ };
612
+ reduceRight: {
613
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
614
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>, initialValue: import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
615
+ <U>(callbackfn: (previousValue: U, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, initialValue: U): U;
616
+ };
617
+ find: {
618
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S | undefined;
619
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T> | undefined;
620
+ };
621
+ findIndex: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => number;
622
+ fill: (value: import("@esportsplus/reactivity").Infer<T>, start?: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[] & {
623
+ clear: () => void;
624
+ dispose: () => void;
625
+ dispatch: <K extends keyof {
626
+ clear: undefined;
627
+ pop: {
628
+ item: T_1[number];
629
+ };
630
+ push: {
631
+ items: T_1[number][];
632
+ };
633
+ reverse: undefined;
634
+ set: {
635
+ index: number;
636
+ item: T_1[number];
637
+ };
638
+ shift: {
639
+ item: T_1[number];
640
+ };
641
+ sort: undefined;
642
+ splice: {
643
+ deleteCount: number;
644
+ items: T_1[number][];
645
+ start: number;
646
+ };
647
+ unshift: {
648
+ items: T_1[number][];
649
+ };
650
+ }, V>(event: K, value?: V | undefined) => void;
651
+ map: any;
652
+ on: <K extends keyof {
653
+ clear: undefined;
654
+ pop: {
655
+ item: T_1[number];
656
+ };
657
+ push: {
658
+ items: T_1[number][];
659
+ };
660
+ reverse: undefined;
661
+ set: {
662
+ index: number;
663
+ item: T_1[number];
664
+ };
665
+ shift: {
666
+ item: T_1[number];
667
+ };
668
+ sort: undefined;
669
+ splice: {
670
+ deleteCount: number;
671
+ items: T_1[number][];
672
+ start: number;
673
+ };
674
+ unshift: {
675
+ items: T_1[number][];
676
+ };
677
+ }>(event: K, listener: {
678
+ (value: {
679
+ clear: undefined;
680
+ pop: {
681
+ item: T;
682
+ };
683
+ push: {
684
+ items: T[];
685
+ };
686
+ reverse: undefined;
687
+ set: {
688
+ index: number;
689
+ item: T;
690
+ };
691
+ shift: {
692
+ item: T;
693
+ };
694
+ sort: undefined;
695
+ splice: {
696
+ deleteCount: number;
697
+ items: T[];
698
+ start: number;
699
+ };
700
+ unshift: {
701
+ items: T[];
702
+ };
703
+ }[K]): void;
704
+ once?: boolean;
705
+ }) => void;
706
+ once: <K extends keyof {
707
+ clear: undefined;
708
+ pop: {
709
+ item: T_1[number];
710
+ };
711
+ push: {
712
+ items: T_1[number][];
713
+ };
714
+ reverse: undefined;
715
+ set: {
716
+ index: number;
717
+ item: T_1[number];
718
+ };
719
+ shift: {
720
+ item: T_1[number];
721
+ };
722
+ sort: undefined;
723
+ splice: {
724
+ deleteCount: number;
725
+ items: T_1[number][];
726
+ start: number;
727
+ };
728
+ unshift: {
729
+ items: T_1[number][];
730
+ };
731
+ }>(event: K, listener: {
732
+ (value: {
733
+ clear: undefined;
734
+ pop: {
735
+ item: T;
736
+ };
737
+ push: {
738
+ items: T[];
739
+ };
740
+ reverse: undefined;
741
+ set: {
742
+ index: number;
743
+ item: T;
744
+ };
745
+ shift: {
746
+ item: T;
747
+ };
748
+ sort: undefined;
749
+ splice: {
750
+ deleteCount: number;
751
+ items: T[];
752
+ start: number;
753
+ };
754
+ unshift: {
755
+ items: T[];
756
+ };
757
+ }[K]): void;
758
+ once?: boolean;
759
+ }) => void;
760
+ };
761
+ copyWithin: (target: number, start: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[] & {
762
+ clear: () => void;
763
+ dispose: () => void;
764
+ dispatch: <K extends keyof {
765
+ clear: undefined;
766
+ pop: {
767
+ item: T_1[number];
768
+ };
769
+ push: {
770
+ items: T_1[number][];
771
+ };
772
+ reverse: undefined;
773
+ set: {
774
+ index: number;
775
+ item: T_1[number];
776
+ };
777
+ shift: {
778
+ item: T_1[number];
779
+ };
780
+ sort: undefined;
781
+ splice: {
782
+ deleteCount: number;
783
+ items: T_1[number][];
784
+ start: number;
785
+ };
786
+ unshift: {
787
+ items: T_1[number][];
788
+ };
789
+ }, V>(event: K, value?: V | undefined) => void;
790
+ map: any;
791
+ on: <K extends keyof {
792
+ clear: undefined;
793
+ pop: {
794
+ item: T_1[number];
795
+ };
796
+ push: {
797
+ items: T_1[number][];
798
+ };
799
+ reverse: undefined;
800
+ set: {
801
+ index: number;
802
+ item: T_1[number];
803
+ };
804
+ shift: {
805
+ item: T_1[number];
806
+ };
807
+ sort: undefined;
808
+ splice: {
809
+ deleteCount: number;
810
+ items: T_1[number][];
811
+ start: number;
812
+ };
813
+ unshift: {
814
+ items: T_1[number][];
815
+ };
816
+ }>(event: K, listener: {
817
+ (value: {
818
+ clear: undefined;
819
+ pop: {
820
+ item: T;
821
+ };
822
+ push: {
823
+ items: T[];
824
+ };
825
+ reverse: undefined;
826
+ set: {
827
+ index: number;
828
+ item: T;
829
+ };
830
+ shift: {
831
+ item: T;
832
+ };
833
+ sort: undefined;
834
+ splice: {
835
+ deleteCount: number;
836
+ items: T[];
837
+ start: number;
838
+ };
839
+ unshift: {
840
+ items: T[];
841
+ };
842
+ }[K]): void;
843
+ once?: boolean;
844
+ }) => void;
845
+ once: <K extends keyof {
846
+ clear: undefined;
847
+ pop: {
848
+ item: T_1[number];
849
+ };
850
+ push: {
851
+ items: T_1[number][];
852
+ };
853
+ reverse: undefined;
854
+ set: {
855
+ index: number;
856
+ item: T_1[number];
857
+ };
858
+ shift: {
859
+ item: T_1[number];
860
+ };
861
+ sort: undefined;
862
+ splice: {
863
+ deleteCount: number;
864
+ items: T_1[number][];
865
+ start: number;
866
+ };
867
+ unshift: {
868
+ items: T_1[number][];
869
+ };
870
+ }>(event: K, listener: {
871
+ (value: {
872
+ clear: undefined;
873
+ pop: {
874
+ item: T;
875
+ };
876
+ push: {
877
+ items: T[];
878
+ };
879
+ reverse: undefined;
880
+ set: {
881
+ index: number;
882
+ item: T;
883
+ };
884
+ shift: {
885
+ item: T;
886
+ };
887
+ sort: undefined;
888
+ splice: {
889
+ deleteCount: number;
890
+ items: T[];
891
+ start: number;
892
+ };
893
+ unshift: {
894
+ items: T[];
895
+ };
896
+ }[K]): void;
897
+ once?: boolean;
898
+ }) => void;
899
+ };
900
+ entries: () => ArrayIterator<[number, import("@esportsplus/reactivity").Infer<T>]>;
901
+ keys: () => ArrayIterator<number>;
902
+ values: () => ArrayIterator<import("@esportsplus/reactivity").Infer<T>>;
903
+ includes: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => boolean;
904
+ flatMap: <U, This = undefined>(callback: (this: This, value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U | readonly U[], thisArg?: This | undefined) => U[];
905
+ flat: <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
906
+ at: (index: number) => import("@esportsplus/reactivity").Infer<T> | undefined;
907
+ findLast: {
908
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S | undefined;
909
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T> | undefined;
910
+ };
911
+ findLastIndex: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => number;
912
+ toReversed: () => import("@esportsplus/reactivity").Infer<T>[];
913
+ toSorted: (compareFn?: ((a: import("@esportsplus/reactivity").Infer<T>, b: import("@esportsplus/reactivity").Infer<T>) => number) | undefined) => import("@esportsplus/reactivity").Infer<T>[];
914
+ toSpliced: {
915
+ (start: number, deleteCount: number, ...items: import("@esportsplus/reactivity").Infer<T>[]): import("@esportsplus/reactivity").Infer<T>[];
916
+ (start: number, deleteCount?: number): import("@esportsplus/reactivity").Infer<T>[];
917
+ };
918
+ with: (index: number, value: import("@esportsplus/reactivity").Infer<T>) => import("@esportsplus/reactivity").Infer<T>[];
919
+ [Symbol.iterator]: () => ArrayIterator<import("@esportsplus/reactivity").Infer<T>>;
920
+ readonly [Symbol.unscopables]: {
921
+ [x: number]: boolean | undefined;
922
+ length?: boolean | undefined;
923
+ toString?: boolean | undefined;
924
+ toLocaleString?: boolean | undefined;
925
+ pop?: boolean | undefined;
926
+ push?: boolean | undefined;
927
+ concat?: boolean | undefined;
928
+ join?: boolean | undefined;
929
+ reverse?: boolean | undefined;
930
+ shift?: boolean | undefined;
931
+ slice?: boolean | undefined;
932
+ sort?: boolean | undefined;
933
+ splice?: boolean | undefined;
934
+ unshift?: boolean | undefined;
935
+ indexOf?: boolean | undefined;
936
+ lastIndexOf?: boolean | undefined;
937
+ every?: boolean | undefined;
938
+ some?: boolean | undefined;
939
+ forEach?: boolean | undefined;
940
+ map?: boolean | undefined;
941
+ filter?: boolean | undefined;
942
+ reduce?: boolean | undefined;
943
+ reduceRight?: boolean | undefined;
944
+ find?: boolean | undefined;
945
+ findIndex?: boolean | undefined;
946
+ fill?: boolean | undefined;
947
+ copyWithin?: boolean | undefined;
948
+ entries?: boolean | undefined;
949
+ keys?: boolean | undefined;
950
+ values?: boolean | undefined;
951
+ includes?: boolean | undefined;
952
+ flatMap?: boolean | undefined;
953
+ flat?: boolean | undefined;
954
+ at?: boolean | undefined;
955
+ findLast?: boolean | undefined;
956
+ findLastIndex?: boolean | undefined;
957
+ toReversed?: boolean | undefined;
958
+ toSorted?: boolean | undefined;
959
+ toSpliced?: boolean | undefined;
960
+ with?: boolean | undefined;
961
+ [Symbol.iterator]?: boolean | undefined;
962
+ readonly [Symbol.unscopables]?: boolean | undefined;
963
+ };
964
+ clear: () => void;
965
+ dispose: () => void;
966
+ dispatch: <K extends keyof {
967
+ clear: undefined;
968
+ pop: {
969
+ item: T_1[number];
970
+ };
971
+ push: {
972
+ items: T_1[number][];
973
+ };
974
+ reverse: undefined;
975
+ set: {
976
+ index: number;
977
+ item: T_1[number];
978
+ };
979
+ shift: {
980
+ item: T_1[number];
981
+ };
982
+ sort: undefined;
983
+ splice: {
984
+ deleteCount: number;
985
+ items: T_1[number][];
986
+ start: number;
987
+ };
988
+ unshift: {
989
+ items: T_1[number][];
990
+ };
991
+ }, V>(event: K, value?: V | undefined) => void;
992
+ on: <K extends keyof {
993
+ clear: undefined;
994
+ pop: {
995
+ item: T_1[number];
996
+ };
997
+ push: {
998
+ items: T_1[number][];
999
+ };
1000
+ reverse: undefined;
1001
+ set: {
1002
+ index: number;
1003
+ item: T_1[number];
1004
+ };
1005
+ shift: {
1006
+ item: T_1[number];
1007
+ };
1008
+ sort: undefined;
1009
+ splice: {
1010
+ deleteCount: number;
1011
+ items: T_1[number][];
1012
+ start: number;
1013
+ };
1014
+ unshift: {
1015
+ items: T_1[number][];
1016
+ };
1017
+ }>(event: K, listener: {
1018
+ (value: {
1019
+ clear: undefined;
1020
+ pop: {
1021
+ item: T;
1022
+ };
1023
+ push: {
1024
+ items: T[];
1025
+ };
1026
+ reverse: undefined;
1027
+ set: {
1028
+ index: number;
1029
+ item: T;
1030
+ };
1031
+ shift: {
1032
+ item: T;
1033
+ };
1034
+ sort: undefined;
1035
+ splice: {
1036
+ deleteCount: number;
1037
+ items: T[];
1038
+ start: number;
1039
+ };
1040
+ unshift: {
1041
+ items: T[];
1042
+ };
1043
+ }[K]): void;
1044
+ once?: boolean;
1045
+ }) => void;
1046
+ once: <K extends keyof {
1047
+ clear: undefined;
1048
+ pop: {
1049
+ item: T_1[number];
1050
+ };
1051
+ push: {
1052
+ items: T_1[number][];
1053
+ };
1054
+ reverse: undefined;
1055
+ set: {
1056
+ index: number;
1057
+ item: T_1[number];
1058
+ };
1059
+ shift: {
1060
+ item: T_1[number];
1061
+ };
1062
+ sort: undefined;
1063
+ splice: {
1064
+ deleteCount: number;
1065
+ items: T_1[number][];
1066
+ start: number;
1067
+ };
1068
+ unshift: {
1069
+ items: T_1[number][];
1070
+ };
1071
+ }>(event: K, listener: {
1072
+ (value: {
1073
+ clear: undefined;
1074
+ pop: {
1075
+ item: T;
1076
+ };
1077
+ push: {
1078
+ items: T[];
1079
+ };
1080
+ reverse: undefined;
1081
+ set: {
1082
+ index: number;
1083
+ item: T;
1084
+ };
1085
+ shift: {
1086
+ item: T;
1087
+ };
1088
+ sort: undefined;
1089
+ splice: {
1090
+ deleteCount: number;
1091
+ items: T[];
1092
+ start: number;
1093
+ };
1094
+ unshift: {
1095
+ items: T[];
1096
+ };
1097
+ }[K]): void;
1098
+ once?: boolean;
1099
+ }) => void;
1100
+ }, value: T, i: number) => R) => R[]);
1101
+ filter: {
1102
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S[];
1103
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T>[];
1104
+ };
1105
+ reduce: {
1106
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1107
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>, initialValue: import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1108
+ <U>(callbackfn: (previousValue: U, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, initialValue: U): U;
1109
+ };
1110
+ reduceRight: {
1111
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1112
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>, initialValue: import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1113
+ <U>(callbackfn: (previousValue: U, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, initialValue: U): U;
1114
+ };
1115
+ find: {
1116
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S | undefined;
1117
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T> | undefined;
1118
+ };
1119
+ findIndex: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => number;
1120
+ fill: (value: import("@esportsplus/reactivity").Infer<T>, start?: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[] & {
1121
+ clear: () => void;
1122
+ dispose: () => void;
1123
+ dispatch: <K extends keyof {
1124
+ clear: undefined;
1125
+ pop: {
1126
+ item: T_1[number];
1127
+ };
1128
+ push: {
1129
+ items: T_1[number][];
1130
+ };
1131
+ reverse: undefined;
1132
+ set: {
1133
+ index: number;
1134
+ item: T_1[number];
1135
+ };
1136
+ shift: {
1137
+ item: T_1[number];
1138
+ };
1139
+ sort: undefined;
1140
+ splice: {
1141
+ deleteCount: number;
1142
+ items: T_1[number][];
1143
+ start: number;
1144
+ };
1145
+ unshift: {
1146
+ items: T_1[number][];
1147
+ };
1148
+ }, V>(event: K, value?: V | undefined) => void;
1149
+ map: <R>(fn: (this: {
1150
+ [x: number]: import("@esportsplus/reactivity").Infer<T>;
1151
+ length: number;
1152
+ toString: () => string;
1153
+ toLocaleString: {
1154
+ (): string;
1155
+ (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
1156
+ };
1157
+ pop: () => import("@esportsplus/reactivity").Infer<T> | undefined;
1158
+ push: (...items: import("@esportsplus/reactivity").Infer<T>[]) => number;
1159
+ concat: {
1160
+ (...items: ConcatArray<import("@esportsplus/reactivity").Infer<T>>[]): import("@esportsplus/reactivity").Infer<T>[];
1161
+ (...items: (import("@esportsplus/reactivity").Infer<T> | ConcatArray<import("@esportsplus/reactivity").Infer<T>>)[]): import("@esportsplus/reactivity").Infer<T>[];
1162
+ };
1163
+ join: (separator?: string) => string;
1164
+ reverse: () => import("@esportsplus/reactivity").Infer<T>[];
1165
+ shift: () => import("@esportsplus/reactivity").Infer<T> | undefined;
1166
+ slice: (start?: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[];
1167
+ sort: (compareFn?: ((a: import("@esportsplus/reactivity").Infer<T>, b: import("@esportsplus/reactivity").Infer<T>) => number) | undefined) => import("@esportsplus/reactivity").Infer<T>[] & any;
1168
+ splice: {
1169
+ (start: number, deleteCount?: number): import("@esportsplus/reactivity").Infer<T>[];
1170
+ (start: number, deleteCount: number, ...items: import("@esportsplus/reactivity").Infer<T>[]): import("@esportsplus/reactivity").Infer<T>[];
1171
+ };
1172
+ unshift: (...items: import("@esportsplus/reactivity").Infer<T>[]) => number;
1173
+ indexOf: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => number;
1174
+ lastIndexOf: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => number;
1175
+ every: {
1176
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): this is S[];
1177
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): boolean;
1178
+ };
1179
+ some: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => boolean;
1180
+ forEach: (callbackfn: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => void, thisArg?: any) => void;
1181
+ map: (<U>(callbackfn: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, thisArg?: any) => U[]) & any;
1182
+ filter: {
1183
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S[];
1184
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T>[];
1185
+ };
1186
+ reduce: {
1187
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1188
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>, initialValue: import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1189
+ <U>(callbackfn: (previousValue: U, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, initialValue: U): U;
1190
+ };
1191
+ reduceRight: {
1192
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1193
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>, initialValue: import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1194
+ <U>(callbackfn: (previousValue: U, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, initialValue: U): U;
1195
+ };
1196
+ find: {
1197
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S | undefined;
1198
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T> | undefined;
1199
+ };
1200
+ findIndex: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => number;
1201
+ fill: any;
1202
+ copyWithin: (target: number, start: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[] & any;
1203
+ entries: () => ArrayIterator<[number, import("@esportsplus/reactivity").Infer<T>]>;
1204
+ keys: () => ArrayIterator<number>;
1205
+ values: () => ArrayIterator<import("@esportsplus/reactivity").Infer<T>>;
1206
+ includes: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => boolean;
1207
+ flatMap: <U, This = undefined>(callback: (this: This, value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U | readonly U[], thisArg?: This | undefined) => U[];
1208
+ flat: <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
1209
+ at: (index: number) => import("@esportsplus/reactivity").Infer<T> | undefined;
1210
+ findLast: {
1211
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S | undefined;
1212
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T> | undefined;
1213
+ };
1214
+ findLastIndex: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => number;
1215
+ toReversed: () => import("@esportsplus/reactivity").Infer<T>[];
1216
+ toSorted: (compareFn?: ((a: import("@esportsplus/reactivity").Infer<T>, b: import("@esportsplus/reactivity").Infer<T>) => number) | undefined) => import("@esportsplus/reactivity").Infer<T>[];
1217
+ toSpliced: {
1218
+ (start: number, deleteCount: number, ...items: import("@esportsplus/reactivity").Infer<T>[]): import("@esportsplus/reactivity").Infer<T>[];
1219
+ (start: number, deleteCount?: number): import("@esportsplus/reactivity").Infer<T>[];
1220
+ };
1221
+ with: (index: number, value: import("@esportsplus/reactivity").Infer<T>) => import("@esportsplus/reactivity").Infer<T>[];
1222
+ [Symbol.iterator]: () => ArrayIterator<import("@esportsplus/reactivity").Infer<T>>;
1223
+ readonly [Symbol.unscopables]: {
1224
+ [x: number]: boolean | undefined;
1225
+ length?: boolean | undefined;
1226
+ toString?: boolean | undefined;
1227
+ toLocaleString?: boolean | undefined;
1228
+ pop?: boolean | undefined;
1229
+ push?: boolean | undefined;
1230
+ concat?: boolean | undefined;
1231
+ join?: boolean | undefined;
1232
+ reverse?: boolean | undefined;
1233
+ shift?: boolean | undefined;
1234
+ slice?: boolean | undefined;
1235
+ sort?: boolean | undefined;
1236
+ splice?: boolean | undefined;
1237
+ unshift?: boolean | undefined;
1238
+ indexOf?: boolean | undefined;
1239
+ lastIndexOf?: boolean | undefined;
1240
+ every?: boolean | undefined;
1241
+ some?: boolean | undefined;
1242
+ forEach?: boolean | undefined;
1243
+ map?: boolean | undefined;
1244
+ filter?: boolean | undefined;
1245
+ reduce?: boolean | undefined;
1246
+ reduceRight?: boolean | undefined;
1247
+ find?: boolean | undefined;
1248
+ findIndex?: boolean | undefined;
1249
+ fill?: boolean | undefined;
1250
+ copyWithin?: boolean | undefined;
1251
+ entries?: boolean | undefined;
1252
+ keys?: boolean | undefined;
1253
+ values?: boolean | undefined;
1254
+ includes?: boolean | undefined;
1255
+ flatMap?: boolean | undefined;
1256
+ flat?: boolean | undefined;
1257
+ at?: boolean | undefined;
1258
+ findLast?: boolean | undefined;
1259
+ findLastIndex?: boolean | undefined;
1260
+ toReversed?: boolean | undefined;
1261
+ toSorted?: boolean | undefined;
1262
+ toSpliced?: boolean | undefined;
1263
+ with?: boolean | undefined;
1264
+ [Symbol.iterator]?: boolean | undefined;
1265
+ readonly [Symbol.unscopables]?: boolean | undefined;
1266
+ };
1267
+ clear: () => void;
1268
+ dispose: () => void;
1269
+ dispatch: <K extends keyof {
1270
+ clear: undefined;
1271
+ pop: {
1272
+ item: T_1[number];
1273
+ };
1274
+ push: {
1275
+ items: T_1[number][];
1276
+ };
1277
+ reverse: undefined;
1278
+ set: {
1279
+ index: number;
1280
+ item: T_1[number];
1281
+ };
1282
+ shift: {
1283
+ item: T_1[number];
1284
+ };
1285
+ sort: undefined;
1286
+ splice: {
1287
+ deleteCount: number;
1288
+ items: T_1[number][];
1289
+ start: number;
1290
+ };
1291
+ unshift: {
1292
+ items: T_1[number][];
1293
+ };
1294
+ }, V>(event: K, value?: V | undefined) => void;
1295
+ on: <K extends keyof {
1296
+ clear: undefined;
1297
+ pop: {
1298
+ item: T_1[number];
1299
+ };
1300
+ push: {
1301
+ items: T_1[number][];
1302
+ };
1303
+ reverse: undefined;
1304
+ set: {
1305
+ index: number;
1306
+ item: T_1[number];
1307
+ };
1308
+ shift: {
1309
+ item: T_1[number];
1310
+ };
1311
+ sort: undefined;
1312
+ splice: {
1313
+ deleteCount: number;
1314
+ items: T_1[number][];
1315
+ start: number;
1316
+ };
1317
+ unshift: {
1318
+ items: T_1[number][];
1319
+ };
1320
+ }>(event: K, listener: {
1321
+ (value: {
1322
+ clear: undefined;
1323
+ pop: {
1324
+ item: T;
1325
+ };
1326
+ push: {
1327
+ items: T[];
1328
+ };
1329
+ reverse: undefined;
1330
+ set: {
1331
+ index: number;
1332
+ item: T;
1333
+ };
1334
+ shift: {
1335
+ item: T;
1336
+ };
1337
+ sort: undefined;
1338
+ splice: {
1339
+ deleteCount: number;
1340
+ items: T[];
1341
+ start: number;
1342
+ };
1343
+ unshift: {
1344
+ items: T[];
1345
+ };
1346
+ }[K]): void;
1347
+ once?: boolean;
1348
+ }) => void;
1349
+ once: <K extends keyof {
1350
+ clear: undefined;
1351
+ pop: {
1352
+ item: T_1[number];
1353
+ };
1354
+ push: {
1355
+ items: T_1[number][];
1356
+ };
1357
+ reverse: undefined;
1358
+ set: {
1359
+ index: number;
1360
+ item: T_1[number];
1361
+ };
1362
+ shift: {
1363
+ item: T_1[number];
1364
+ };
1365
+ sort: undefined;
1366
+ splice: {
1367
+ deleteCount: number;
1368
+ items: T_1[number][];
1369
+ start: number;
1370
+ };
1371
+ unshift: {
1372
+ items: T_1[number][];
1373
+ };
1374
+ }>(event: K, listener: {
1375
+ (value: {
1376
+ clear: undefined;
1377
+ pop: {
1378
+ item: T;
1379
+ };
1380
+ push: {
1381
+ items: T[];
1382
+ };
1383
+ reverse: undefined;
1384
+ set: {
1385
+ index: number;
1386
+ item: T;
1387
+ };
1388
+ shift: {
1389
+ item: T;
1390
+ };
1391
+ sort: undefined;
1392
+ splice: {
1393
+ deleteCount: number;
1394
+ items: T[];
1395
+ start: number;
1396
+ };
1397
+ unshift: {
1398
+ items: T[];
1399
+ };
1400
+ }[K]): void;
1401
+ once?: boolean;
1402
+ }) => void;
1403
+ }, value: T, i: number) => R) => R[];
1404
+ on: <K extends keyof {
1405
+ clear: undefined;
1406
+ pop: {
1407
+ item: T_1[number];
1408
+ };
1409
+ push: {
1410
+ items: T_1[number][];
1411
+ };
1412
+ reverse: undefined;
1413
+ set: {
1414
+ index: number;
1415
+ item: T_1[number];
1416
+ };
1417
+ shift: {
1418
+ item: T_1[number];
1419
+ };
1420
+ sort: undefined;
1421
+ splice: {
1422
+ deleteCount: number;
1423
+ items: T_1[number][];
1424
+ start: number;
1425
+ };
1426
+ unshift: {
1427
+ items: T_1[number][];
1428
+ };
1429
+ }>(event: K, listener: {
1430
+ (value: {
1431
+ clear: undefined;
1432
+ pop: {
1433
+ item: T;
1434
+ };
1435
+ push: {
1436
+ items: T[];
1437
+ };
1438
+ reverse: undefined;
1439
+ set: {
1440
+ index: number;
1441
+ item: T;
1442
+ };
1443
+ shift: {
1444
+ item: T;
1445
+ };
1446
+ sort: undefined;
1447
+ splice: {
1448
+ deleteCount: number;
1449
+ items: T[];
1450
+ start: number;
1451
+ };
1452
+ unshift: {
1453
+ items: T[];
1454
+ };
1455
+ }[K]): void;
1456
+ once?: boolean;
1457
+ }) => void;
1458
+ once: <K extends keyof {
1459
+ clear: undefined;
1460
+ pop: {
1461
+ item: T_1[number];
1462
+ };
1463
+ push: {
1464
+ items: T_1[number][];
1465
+ };
1466
+ reverse: undefined;
1467
+ set: {
1468
+ index: number;
1469
+ item: T_1[number];
1470
+ };
1471
+ shift: {
1472
+ item: T_1[number];
1473
+ };
1474
+ sort: undefined;
1475
+ splice: {
1476
+ deleteCount: number;
1477
+ items: T_1[number][];
1478
+ start: number;
1479
+ };
1480
+ unshift: {
1481
+ items: T_1[number][];
1482
+ };
1483
+ }>(event: K, listener: {
1484
+ (value: {
1485
+ clear: undefined;
1486
+ pop: {
1487
+ item: T;
1488
+ };
1489
+ push: {
1490
+ items: T[];
1491
+ };
1492
+ reverse: undefined;
1493
+ set: {
1494
+ index: number;
1495
+ item: T;
1496
+ };
1497
+ shift: {
1498
+ item: T;
1499
+ };
1500
+ sort: undefined;
1501
+ splice: {
1502
+ deleteCount: number;
1503
+ items: T[];
1504
+ start: number;
1505
+ };
1506
+ unshift: {
1507
+ items: T[];
1508
+ };
1509
+ }[K]): void;
1510
+ once?: boolean;
1511
+ }) => void;
1512
+ };
1513
+ copyWithin: (target: number, start: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[] & {
1514
+ clear: () => void;
1515
+ dispose: () => void;
1516
+ dispatch: <K extends keyof {
1517
+ clear: undefined;
1518
+ pop: {
1519
+ item: T_1[number];
1520
+ };
1521
+ push: {
1522
+ items: T_1[number][];
1523
+ };
1524
+ reverse: undefined;
1525
+ set: {
1526
+ index: number;
1527
+ item: T_1[number];
1528
+ };
1529
+ shift: {
1530
+ item: T_1[number];
1531
+ };
1532
+ sort: undefined;
1533
+ splice: {
1534
+ deleteCount: number;
1535
+ items: T_1[number][];
1536
+ start: number;
1537
+ };
1538
+ unshift: {
1539
+ items: T_1[number][];
1540
+ };
1541
+ }, V>(event: K, value?: V | undefined) => void;
1542
+ map: <R>(fn: (this: {
1543
+ [x: number]: import("@esportsplus/reactivity").Infer<T>;
1544
+ length: number;
1545
+ toString: () => string;
1546
+ toLocaleString: {
1547
+ (): string;
1548
+ (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
1549
+ };
1550
+ pop: () => import("@esportsplus/reactivity").Infer<T> | undefined;
1551
+ push: (...items: import("@esportsplus/reactivity").Infer<T>[]) => number;
1552
+ concat: {
1553
+ (...items: ConcatArray<import("@esportsplus/reactivity").Infer<T>>[]): import("@esportsplus/reactivity").Infer<T>[];
1554
+ (...items: (import("@esportsplus/reactivity").Infer<T> | ConcatArray<import("@esportsplus/reactivity").Infer<T>>)[]): import("@esportsplus/reactivity").Infer<T>[];
1555
+ };
1556
+ join: (separator?: string) => string;
1557
+ reverse: () => import("@esportsplus/reactivity").Infer<T>[];
1558
+ shift: () => import("@esportsplus/reactivity").Infer<T> | undefined;
1559
+ slice: (start?: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[];
1560
+ sort: (compareFn?: ((a: import("@esportsplus/reactivity").Infer<T>, b: import("@esportsplus/reactivity").Infer<T>) => number) | undefined) => import("@esportsplus/reactivity").Infer<T>[] & any;
1561
+ splice: {
1562
+ (start: number, deleteCount?: number): import("@esportsplus/reactivity").Infer<T>[];
1563
+ (start: number, deleteCount: number, ...items: import("@esportsplus/reactivity").Infer<T>[]): import("@esportsplus/reactivity").Infer<T>[];
1564
+ };
1565
+ unshift: (...items: import("@esportsplus/reactivity").Infer<T>[]) => number;
1566
+ indexOf: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => number;
1567
+ lastIndexOf: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => number;
1568
+ every: {
1569
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): this is S[];
1570
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): boolean;
1571
+ };
1572
+ some: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => boolean;
1573
+ forEach: (callbackfn: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => void, thisArg?: any) => void;
1574
+ map: (<U>(callbackfn: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, thisArg?: any) => U[]) & any;
1575
+ filter: {
1576
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S[];
1577
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T>[];
1578
+ };
1579
+ reduce: {
1580
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1581
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>, initialValue: import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1582
+ <U>(callbackfn: (previousValue: U, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, initialValue: U): U;
1583
+ };
1584
+ reduceRight: {
1585
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1586
+ (callbackfn: (previousValue: import("@esportsplus/reactivity").Infer<T>, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => import("@esportsplus/reactivity").Infer<T>, initialValue: import("@esportsplus/reactivity").Infer<T>): import("@esportsplus/reactivity").Infer<T>;
1587
+ <U>(callbackfn: (previousValue: U, currentValue: import("@esportsplus/reactivity").Infer<T>, currentIndex: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U, initialValue: U): U;
1588
+ };
1589
+ find: {
1590
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S | undefined;
1591
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T> | undefined;
1592
+ };
1593
+ findIndex: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, obj: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => number;
1594
+ fill: (value: import("@esportsplus/reactivity").Infer<T>, start?: number, end?: number) => import("@esportsplus/reactivity").Infer<T>[] & any;
1595
+ copyWithin: any;
1596
+ entries: () => ArrayIterator<[number, import("@esportsplus/reactivity").Infer<T>]>;
1597
+ keys: () => ArrayIterator<number>;
1598
+ values: () => ArrayIterator<import("@esportsplus/reactivity").Infer<T>>;
1599
+ includes: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => boolean;
1600
+ flatMap: <U, This = undefined>(callback: (this: This, value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U | readonly U[], thisArg?: This | undefined) => U[];
1601
+ flat: <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
1602
+ at: (index: number) => import("@esportsplus/reactivity").Infer<T> | undefined;
1603
+ findLast: {
1604
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S | undefined;
1605
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T> | undefined;
1606
+ };
1607
+ findLastIndex: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => number;
1608
+ toReversed: () => import("@esportsplus/reactivity").Infer<T>[];
1609
+ toSorted: (compareFn?: ((a: import("@esportsplus/reactivity").Infer<T>, b: import("@esportsplus/reactivity").Infer<T>) => number) | undefined) => import("@esportsplus/reactivity").Infer<T>[];
1610
+ toSpliced: {
1611
+ (start: number, deleteCount: number, ...items: import("@esportsplus/reactivity").Infer<T>[]): import("@esportsplus/reactivity").Infer<T>[];
1612
+ (start: number, deleteCount?: number): import("@esportsplus/reactivity").Infer<T>[];
1613
+ };
1614
+ with: (index: number, value: import("@esportsplus/reactivity").Infer<T>) => import("@esportsplus/reactivity").Infer<T>[];
1615
+ [Symbol.iterator]: () => ArrayIterator<import("@esportsplus/reactivity").Infer<T>>;
1616
+ readonly [Symbol.unscopables]: {
1617
+ [x: number]: boolean | undefined;
1618
+ length?: boolean | undefined;
1619
+ toString?: boolean | undefined;
1620
+ toLocaleString?: boolean | undefined;
1621
+ pop?: boolean | undefined;
1622
+ push?: boolean | undefined;
1623
+ concat?: boolean | undefined;
1624
+ join?: boolean | undefined;
1625
+ reverse?: boolean | undefined;
1626
+ shift?: boolean | undefined;
1627
+ slice?: boolean | undefined;
1628
+ sort?: boolean | undefined;
1629
+ splice?: boolean | undefined;
1630
+ unshift?: boolean | undefined;
1631
+ indexOf?: boolean | undefined;
1632
+ lastIndexOf?: boolean | undefined;
1633
+ every?: boolean | undefined;
1634
+ some?: boolean | undefined;
1635
+ forEach?: boolean | undefined;
1636
+ map?: boolean | undefined;
1637
+ filter?: boolean | undefined;
1638
+ reduce?: boolean | undefined;
1639
+ reduceRight?: boolean | undefined;
1640
+ find?: boolean | undefined;
1641
+ findIndex?: boolean | undefined;
1642
+ fill?: boolean | undefined;
1643
+ copyWithin?: boolean | undefined;
1644
+ entries?: boolean | undefined;
1645
+ keys?: boolean | undefined;
1646
+ values?: boolean | undefined;
1647
+ includes?: boolean | undefined;
1648
+ flatMap?: boolean | undefined;
1649
+ flat?: boolean | undefined;
1650
+ at?: boolean | undefined;
1651
+ findLast?: boolean | undefined;
1652
+ findLastIndex?: boolean | undefined;
1653
+ toReversed?: boolean | undefined;
1654
+ toSorted?: boolean | undefined;
1655
+ toSpliced?: boolean | undefined;
1656
+ with?: boolean | undefined;
1657
+ [Symbol.iterator]?: boolean | undefined;
1658
+ readonly [Symbol.unscopables]?: boolean | undefined;
1659
+ };
1660
+ clear: () => void;
1661
+ dispose: () => void;
1662
+ dispatch: <K extends keyof {
1663
+ clear: undefined;
1664
+ pop: {
1665
+ item: T_1[number];
1666
+ };
1667
+ push: {
1668
+ items: T_1[number][];
1669
+ };
1670
+ reverse: undefined;
1671
+ set: {
1672
+ index: number;
1673
+ item: T_1[number];
1674
+ };
1675
+ shift: {
1676
+ item: T_1[number];
1677
+ };
1678
+ sort: undefined;
1679
+ splice: {
1680
+ deleteCount: number;
1681
+ items: T_1[number][];
1682
+ start: number;
1683
+ };
1684
+ unshift: {
1685
+ items: T_1[number][];
1686
+ };
1687
+ }, V>(event: K, value?: V | undefined) => void;
1688
+ on: <K extends keyof {
1689
+ clear: undefined;
1690
+ pop: {
1691
+ item: T_1[number];
1692
+ };
1693
+ push: {
1694
+ items: T_1[number][];
1695
+ };
1696
+ reverse: undefined;
1697
+ set: {
1698
+ index: number;
1699
+ item: T_1[number];
1700
+ };
1701
+ shift: {
1702
+ item: T_1[number];
1703
+ };
1704
+ sort: undefined;
1705
+ splice: {
1706
+ deleteCount: number;
1707
+ items: T_1[number][];
1708
+ start: number;
1709
+ };
1710
+ unshift: {
1711
+ items: T_1[number][];
1712
+ };
1713
+ }>(event: K, listener: {
1714
+ (value: {
1715
+ clear: undefined;
1716
+ pop: {
1717
+ item: T;
1718
+ };
1719
+ push: {
1720
+ items: T[];
1721
+ };
1722
+ reverse: undefined;
1723
+ set: {
1724
+ index: number;
1725
+ item: T;
1726
+ };
1727
+ shift: {
1728
+ item: T;
1729
+ };
1730
+ sort: undefined;
1731
+ splice: {
1732
+ deleteCount: number;
1733
+ items: T[];
1734
+ start: number;
1735
+ };
1736
+ unshift: {
1737
+ items: T[];
1738
+ };
1739
+ }[K]): void;
1740
+ once?: boolean;
1741
+ }) => void;
1742
+ once: <K extends keyof {
1743
+ clear: undefined;
1744
+ pop: {
1745
+ item: T_1[number];
1746
+ };
1747
+ push: {
1748
+ items: T_1[number][];
1749
+ };
1750
+ reverse: undefined;
1751
+ set: {
1752
+ index: number;
1753
+ item: T_1[number];
1754
+ };
1755
+ shift: {
1756
+ item: T_1[number];
1757
+ };
1758
+ sort: undefined;
1759
+ splice: {
1760
+ deleteCount: number;
1761
+ items: T_1[number][];
1762
+ start: number;
1763
+ };
1764
+ unshift: {
1765
+ items: T_1[number][];
1766
+ };
1767
+ }>(event: K, listener: {
1768
+ (value: {
1769
+ clear: undefined;
1770
+ pop: {
1771
+ item: T;
1772
+ };
1773
+ push: {
1774
+ items: T[];
1775
+ };
1776
+ reverse: undefined;
1777
+ set: {
1778
+ index: number;
1779
+ item: T;
1780
+ };
1781
+ shift: {
1782
+ item: T;
1783
+ };
1784
+ sort: undefined;
1785
+ splice: {
1786
+ deleteCount: number;
1787
+ items: T[];
1788
+ start: number;
1789
+ };
1790
+ unshift: {
1791
+ items: T[];
1792
+ };
1793
+ }[K]): void;
1794
+ once?: boolean;
1795
+ }) => void;
1796
+ }, value: T, i: number) => R) => R[];
1797
+ on: <K extends keyof {
1798
+ clear: undefined;
1799
+ pop: {
1800
+ item: T_1[number];
1801
+ };
1802
+ push: {
1803
+ items: T_1[number][];
1804
+ };
1805
+ reverse: undefined;
1806
+ set: {
1807
+ index: number;
1808
+ item: T_1[number];
1809
+ };
1810
+ shift: {
1811
+ item: T_1[number];
1812
+ };
1813
+ sort: undefined;
1814
+ splice: {
1815
+ deleteCount: number;
1816
+ items: T_1[number][];
1817
+ start: number;
1818
+ };
1819
+ unshift: {
1820
+ items: T_1[number][];
1821
+ };
1822
+ }>(event: K, listener: {
1823
+ (value: {
1824
+ clear: undefined;
1825
+ pop: {
1826
+ item: T;
1827
+ };
1828
+ push: {
1829
+ items: T[];
1830
+ };
1831
+ reverse: undefined;
1832
+ set: {
1833
+ index: number;
1834
+ item: T;
1835
+ };
1836
+ shift: {
1837
+ item: T;
1838
+ };
1839
+ sort: undefined;
1840
+ splice: {
1841
+ deleteCount: number;
1842
+ items: T[];
1843
+ start: number;
1844
+ };
1845
+ unshift: {
1846
+ items: T[];
1847
+ };
1848
+ }[K]): void;
1849
+ once?: boolean;
1850
+ }) => void;
1851
+ once: <K extends keyof {
1852
+ clear: undefined;
1853
+ pop: {
1854
+ item: T_1[number];
1855
+ };
1856
+ push: {
1857
+ items: T_1[number][];
1858
+ };
1859
+ reverse: undefined;
1860
+ set: {
1861
+ index: number;
1862
+ item: T_1[number];
1863
+ };
1864
+ shift: {
1865
+ item: T_1[number];
1866
+ };
1867
+ sort: undefined;
1868
+ splice: {
1869
+ deleteCount: number;
1870
+ items: T_1[number][];
1871
+ start: number;
1872
+ };
1873
+ unshift: {
1874
+ items: T_1[number][];
1875
+ };
1876
+ }>(event: K, listener: {
1877
+ (value: {
1878
+ clear: undefined;
1879
+ pop: {
1880
+ item: T;
1881
+ };
1882
+ push: {
1883
+ items: T[];
1884
+ };
1885
+ reverse: undefined;
1886
+ set: {
1887
+ index: number;
1888
+ item: T;
1889
+ };
1890
+ shift: {
1891
+ item: T;
1892
+ };
1893
+ sort: undefined;
1894
+ splice: {
1895
+ deleteCount: number;
1896
+ items: T[];
1897
+ start: number;
1898
+ };
1899
+ unshift: {
1900
+ items: T[];
1901
+ };
1902
+ }[K]): void;
1903
+ once?: boolean;
1904
+ }) => void;
1905
+ };
1906
+ entries: () => ArrayIterator<[number, import("@esportsplus/reactivity").Infer<T>]>;
1907
+ keys: () => ArrayIterator<number>;
1908
+ values: () => ArrayIterator<import("@esportsplus/reactivity").Infer<T>>;
1909
+ includes: (searchElement: import("@esportsplus/reactivity").Infer<T>, fromIndex?: number) => boolean;
1910
+ flatMap: <U, This = undefined>(callback: (this: This, value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => U | readonly U[], thisArg?: This | undefined) => U[];
1911
+ flat: <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
1912
+ at: (index: number) => import("@esportsplus/reactivity").Infer<T> | undefined;
1913
+ findLast: {
1914
+ <S extends import("@esportsplus/reactivity").Infer<T>>(predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => value is S, thisArg?: any): S | undefined;
1915
+ (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any): import("@esportsplus/reactivity").Infer<T> | undefined;
1916
+ };
1917
+ findLastIndex: (predicate: (value: import("@esportsplus/reactivity").Infer<T>, index: number, array: import("@esportsplus/reactivity").Infer<T>[]) => unknown, thisArg?: any) => number;
1918
+ toReversed: () => import("@esportsplus/reactivity").Infer<T>[];
1919
+ toSorted: (compareFn?: ((a: import("@esportsplus/reactivity").Infer<T>, b: import("@esportsplus/reactivity").Infer<T>) => number) | undefined) => import("@esportsplus/reactivity").Infer<T>[];
1920
+ toSpliced: {
1921
+ (start: number, deleteCount: number, ...items: import("@esportsplus/reactivity").Infer<T>[]): import("@esportsplus/reactivity").Infer<T>[];
1922
+ (start: number, deleteCount?: number): import("@esportsplus/reactivity").Infer<T>[];
1923
+ };
1924
+ with: (index: number, value: import("@esportsplus/reactivity").Infer<T>) => import("@esportsplus/reactivity").Infer<T>[];
1925
+ [Symbol.iterator]: () => ArrayIterator<import("@esportsplus/reactivity").Infer<T>>;
1926
+ readonly [Symbol.unscopables]: {
1927
+ [x: number]: boolean | undefined;
1928
+ length?: boolean | undefined;
1929
+ toString?: boolean | undefined;
1930
+ toLocaleString?: boolean | undefined;
1931
+ pop?: boolean | undefined;
1932
+ push?: boolean | undefined;
1933
+ concat?: boolean | undefined;
1934
+ join?: boolean | undefined;
1935
+ reverse?: boolean | undefined;
1936
+ shift?: boolean | undefined;
1937
+ slice?: boolean | undefined;
1938
+ sort?: boolean | undefined;
1939
+ splice?: boolean | undefined;
1940
+ unshift?: boolean | undefined;
1941
+ indexOf?: boolean | undefined;
1942
+ lastIndexOf?: boolean | undefined;
1943
+ every?: boolean | undefined;
1944
+ some?: boolean | undefined;
1945
+ forEach?: boolean | undefined;
1946
+ map?: boolean | undefined;
1947
+ filter?: boolean | undefined;
1948
+ reduce?: boolean | undefined;
1949
+ reduceRight?: boolean | undefined;
1950
+ find?: boolean | undefined;
1951
+ findIndex?: boolean | undefined;
1952
+ fill?: boolean | undefined;
1953
+ copyWithin?: boolean | undefined;
1954
+ entries?: boolean | undefined;
1955
+ keys?: boolean | undefined;
1956
+ values?: boolean | undefined;
1957
+ includes?: boolean | undefined;
1958
+ flatMap?: boolean | undefined;
1959
+ flat?: boolean | undefined;
1960
+ at?: boolean | undefined;
1961
+ findLast?: boolean | undefined;
1962
+ findLastIndex?: boolean | undefined;
1963
+ toReversed?: boolean | undefined;
1964
+ toSorted?: boolean | undefined;
1965
+ toSpliced?: boolean | undefined;
1966
+ with?: boolean | undefined;
1967
+ [Symbol.iterator]?: boolean | undefined;
1968
+ readonly [Symbol.unscopables]?: boolean | undefined;
1969
+ };
1970
+ clear: () => void;
1971
+ dispose: () => void;
1972
+ dispatch: <K extends keyof {
1973
+ clear: undefined;
1974
+ pop: {
1975
+ item: T_1[number];
1976
+ };
1977
+ push: {
1978
+ items: T_1[number][];
1979
+ };
1980
+ reverse: undefined;
1981
+ set: {
1982
+ index: number;
1983
+ item: T_1[number];
1984
+ };
1985
+ shift: {
1986
+ item: T_1[number];
1987
+ };
1988
+ sort: undefined;
1989
+ splice: {
1990
+ deleteCount: number;
1991
+ items: T_1[number][];
1992
+ start: number;
1993
+ };
1994
+ unshift: {
1995
+ items: T_1[number][];
1996
+ };
1997
+ }, V>(event: K, value?: V | undefined) => void;
1998
+ on: <K extends keyof {
1999
+ clear: undefined;
2000
+ pop: {
2001
+ item: T_1[number];
2002
+ };
2003
+ push: {
2004
+ items: T_1[number][];
2005
+ };
2006
+ reverse: undefined;
2007
+ set: {
2008
+ index: number;
2009
+ item: T_1[number];
2010
+ };
2011
+ shift: {
2012
+ item: T_1[number];
2013
+ };
2014
+ sort: undefined;
2015
+ splice: {
2016
+ deleteCount: number;
2017
+ items: T_1[number][];
2018
+ start: number;
2019
+ };
2020
+ unshift: {
2021
+ items: T_1[number][];
2022
+ };
2023
+ }>(event: K, listener: {
2024
+ (value: {
2025
+ clear: undefined;
2026
+ pop: {
2027
+ item: T;
2028
+ };
2029
+ push: {
2030
+ items: T[];
2031
+ };
2032
+ reverse: undefined;
2033
+ set: {
2034
+ index: number;
2035
+ item: T;
2036
+ };
2037
+ shift: {
2038
+ item: T;
2039
+ };
2040
+ sort: undefined;
2041
+ splice: {
2042
+ deleteCount: number;
2043
+ items: T[];
2044
+ start: number;
2045
+ };
2046
+ unshift: {
2047
+ items: T[];
2048
+ };
2049
+ }[K]): void;
2050
+ once?: boolean;
2051
+ }) => void;
2052
+ once: <K extends keyof {
2053
+ clear: undefined;
2054
+ pop: {
2055
+ item: T_1[number];
2056
+ };
2057
+ push: {
2058
+ items: T_1[number][];
2059
+ };
2060
+ reverse: undefined;
2061
+ set: {
2062
+ index: number;
2063
+ item: T_1[number];
2064
+ };
2065
+ shift: {
2066
+ item: T_1[number];
2067
+ };
2068
+ sort: undefined;
2069
+ splice: {
2070
+ deleteCount: number;
2071
+ items: T_1[number][];
2072
+ start: number;
2073
+ };
2074
+ unshift: {
2075
+ items: T_1[number][];
2076
+ };
2077
+ }>(event: K, listener: {
2078
+ (value: {
2079
+ clear: undefined;
2080
+ pop: {
2081
+ item: T;
2082
+ };
2083
+ push: {
2084
+ items: T[];
2085
+ };
2086
+ reverse: undefined;
2087
+ set: {
2088
+ index: number;
2089
+ item: T;
2090
+ };
2091
+ shift: {
2092
+ item: T;
2093
+ };
2094
+ sort: undefined;
2095
+ splice: {
2096
+ deleteCount: number;
2097
+ items: T[];
2098
+ start: number;
2099
+ };
2100
+ unshift: {
2101
+ items: T[];
2102
+ };
2103
+ }[K]): void;
2104
+ once?: boolean;
2105
+ }) => void;
2106
+ };
2107
+ template: (this: ReactiveArray<unknown[]>, value: unknown, i: number) => ReturnType<typeof html>;
2108
+ };
7
2109
  };
8
2110
  export default html;
9
- export { hydrate };