semantic-typescript 0.5.0 → 0.5.3

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 (28) hide show
  1. package/dist/collector.d.ts +1 -10
  2. package/dist/collector.js +1 -20
  3. package/dist/factory.d.ts +72 -28
  4. package/dist/factory.js +362 -150
  5. package/dist/guard.d.ts +1 -14
  6. package/dist/guard.js +1 -61
  7. package/dist/hook.d.ts +5 -1
  8. package/dist/hook.js +72 -19
  9. package/dist/index.d.ts +0 -1
  10. package/dist/index.js +0 -1
  11. package/dist/main.d.ts +1 -0
  12. package/dist/main.js +4 -0
  13. package/dist/map.js +0 -8
  14. package/dist/optional.d.ts +3 -3
  15. package/dist/optional.js +14 -10
  16. package/dist/semantic.d.ts +204 -2
  17. package/dist/semantic.js +1134 -10
  18. package/dist/symbol.d.ts +1 -14
  19. package/dist/symbol.js +1 -14
  20. package/dist/utility.d.ts +1 -1
  21. package/package.json +1 -1
  22. package/readme.md +492 -282
  23. package/dist/collectable.d.ts +0 -202
  24. package/dist/collectable.js +0 -1123
  25. package/dist/statistics.d.ts +0 -97
  26. package/dist/statistics.js +0 -483
  27. package/dist/window.d.ts +0 -12
  28. package/dist/window.js +0 -72
package/dist/factory.js CHANGED
@@ -1,8 +1,10 @@
1
- import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable, isWindow, isString, isDocument } from "./guard";
2
- import { useCompare, useTraverse } from "./hook";
1
+ import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable, isString, isHTMLElemet } from "./guard";
2
+ import { useCompare, useToBigInt, useToNumber, useTraverse } from "./hook";
3
+ import { Optional } from "./optional";
3
4
  import { Semantic } from "./semantic";
4
5
  import { invalidate, validate } from "./utility";
5
- export let animationFrame = (period, delay = 0) => {
6
+ ;
7
+ export let useAnimationFrame = (period, delay = 0) => {
6
8
  if (period <= 0 || !Number.isFinite(period) || delay < 0 || !Number.isFinite(delay)) {
7
9
  throw new TypeError("Period must be positive finite number and delay must be non-negative finite number.");
8
10
  }
@@ -26,12 +28,12 @@ export let animationFrame = (period, delay = 0) => {
26
28
  };
27
29
  }
28
30
  catch (error) {
29
- throw new Error("Uncaught error as creating animation frame semantic.");
31
+ console.error(error);
30
32
  }
31
33
  });
32
34
  };
33
35
  ;
34
- export let attribute = (target) => {
36
+ export let useAttribute = (target) => {
35
37
  if (isObject(target)) {
36
38
  return new Semantic((accept, interrupt) => {
37
39
  try {
@@ -50,13 +52,14 @@ export let attribute = (target) => {
50
52
  });
51
53
  }
52
54
  catch (error) {
53
- throw new Error("Uncaught error as creating attribute semantic.");
55
+ console.error(error);
54
56
  }
55
57
  });
56
58
  }
57
59
  throw new TypeError("Target must be an object.");
58
60
  };
59
- export let blob = (blob, chunk = 64n * 1024n) => {
61
+ ;
62
+ export let useBlob = (blob, chunk = 64n * 1024n) => {
60
63
  let size = Number(chunk);
61
64
  if (size <= 0 || !Number.isSafeInteger(size)) {
62
65
  throw new RangeError("Chunk size must be a safe positive integer.");
@@ -122,136 +125,159 @@ export let blob = (blob, chunk = 64n * 1024n) => {
122
125
  })();
123
126
  }
124
127
  catch (error) {
125
- throw new Error("Uncaught error as creating blob semantic.");
128
+ console.error(error);
126
129
  }
127
130
  });
128
131
  };
129
- export let empty = () => {
130
- return new Semantic(() => { });
132
+ ;
133
+ export let useDocument = (argument) => {
134
+ if (isString(argument)) {
135
+ let key = argument;
136
+ return new Semantic((accept, interrupt) => {
137
+ try {
138
+ let index = 0n;
139
+ let listener = (event) => {
140
+ if (interrupt(event, index)) {
141
+ window.document.addEventListener(key, listener);
142
+ }
143
+ else {
144
+ accept(event, index);
145
+ index++;
146
+ }
147
+ };
148
+ window.document.addEventListener(key, listener);
149
+ }
150
+ catch (error) {
151
+ console.error(error);
152
+ }
153
+ });
154
+ }
155
+ if (isIterable(argument)) {
156
+ let keys = new Set(argument);
157
+ return new Semantic((accept, interrupt) => {
158
+ try {
159
+ let index = 0n;
160
+ for (let key of keys) {
161
+ if (isString(key)) {
162
+ let listener = (event) => {
163
+ if (interrupt(event, index)) {
164
+ window.document.addEventListener(key, listener);
165
+ }
166
+ else {
167
+ accept(event, index);
168
+ index++;
169
+ }
170
+ };
171
+ window.document.addEventListener(key, listener);
172
+ }
173
+ }
174
+ }
175
+ catch (error) {
176
+ console.error(error);
177
+ }
178
+ });
179
+ }
180
+ throw new TypeError("Argument must be a string or an iterable of strings.");
131
181
  };
132
182
  ;
133
- export let event = (argument1, argument2) => {
134
- if (isWindow(argument1)) {
135
- let target = argument1;
183
+ export let useHTMLElement = (argument1, argument2) => {
184
+ if (isString(argument1)) {
185
+ let selector = argument1;
136
186
  if (isString(argument2)) {
137
187
  let key = argument2;
138
188
  return new Semantic((accept, interrupt) => {
139
189
  try {
140
190
  let index = 0n;
141
- let listener = (event) => {
142
- if (interrupt(event, index)) {
143
- target.removeEventListener(key, listener);
144
- }
145
- else {
146
- accept(event, index);
147
- index++;
148
- }
149
- };
150
- target.addEventListener(key, listener);
151
- }
152
- catch (error) {
153
- throw new Error("Uncaught error as creating event semantic.");
154
- }
155
- });
156
- }
157
- if (isIterable(argument2)) {
158
- let keys = argument2;
159
- return new Semantic((accept, interrupt) => {
160
- try {
161
- let index = 0n;
162
- for (let key of keys) {
163
- if (isString(key)) {
191
+ let elements = window.document.querySelectorAll(selector);
192
+ for (let element of elements) {
193
+ if (validate(element)) {
164
194
  let listener = (event) => {
165
195
  if (interrupt(event, index)) {
166
- target.removeEventListener(key, listener);
196
+ element.removeEventListener(key, listener);
167
197
  }
168
198
  else {
169
199
  accept(event, index);
170
200
  index++;
171
201
  }
172
202
  };
173
- target.addEventListener(key, listener);
203
+ element.addEventListener(key, listener);
174
204
  }
175
205
  }
176
206
  }
177
207
  catch (error) {
178
- throw new Error("Uncaught error as creating event semantic.");
179
- }
180
- });
181
- }
182
- }
183
- if (isDocument(argument1)) {
184
- let target = argument1;
185
- if (isString(argument2)) {
186
- let key = argument2;
187
- return new Semantic((accept, interrupt) => {
188
- try {
189
- let index = 0n;
190
- let listener = (event) => {
191
- if (interrupt(event, index)) {
192
- target.removeEventListener(key, listener);
193
- }
194
- else {
195
- accept(event, index);
196
- index++;
197
- }
198
- };
199
- target.addEventListener(key, listener);
200
- }
201
- catch (error) {
202
- throw new Error("Uncaught error as creating event semantic.");
208
+ console.error(error);
203
209
  }
204
210
  });
205
211
  }
206
212
  if (isIterable(argument2)) {
207
- let keys = argument2;
213
+ let keys = new Set(argument2);
208
214
  return new Semantic((accept, interrupt) => {
209
215
  try {
210
216
  let index = 0n;
211
- for (let key of keys) {
212
- if (isString(key)) {
213
- let listener = (event) => {
214
- if (interrupt(event, index)) {
215
- target.removeEventListener(key, listener);
216
- }
217
- else {
218
- accept(event, index);
219
- index++;
220
- }
221
- };
222
- target.addEventListener(key, listener);
217
+ let elements = window.document.querySelectorAll(selector);
218
+ for (let element of elements) {
219
+ for (let key of keys) {
220
+ if (isString(key)) {
221
+ let listener = (event) => {
222
+ if (interrupt(event, index)) {
223
+ element.removeEventListener(key, listener);
224
+ }
225
+ else {
226
+ accept(event, index);
227
+ index++;
228
+ }
229
+ };
230
+ element.addEventListener(key, listener);
231
+ }
223
232
  }
224
233
  }
225
234
  }
226
235
  catch (error) {
227
- throw new Error("Uncaught error as creating event semantic.");
236
+ console.error(error);
228
237
  }
229
238
  });
230
239
  }
231
240
  }
232
241
  if (isIterable(argument1)) {
233
- let targets = argument1;
242
+ let elementsOrSelectors = argument1;
234
243
  if (isString(argument2)) {
235
244
  let key = argument2;
236
245
  return new Semantic((accept, interrupt) => {
237
246
  try {
238
247
  let index = 0n;
239
- for (let target of targets) {
240
- if (isObject(target) && isFunction(Reflect.get(target, "addEventListener"))) {
248
+ for (let elementOrSelector of elementsOrSelectors) {
249
+ if (isString(elementOrSelector)) {
250
+ let element = window.document.querySelector(elementOrSelector);
251
+ if (validate(element)) {
252
+ let listener = (event) => {
253
+ if (interrupt(event, index)) {
254
+ element.removeEventListener(key, listener);
255
+ }
256
+ else {
257
+ accept(event, index);
258
+ index++;
259
+ }
260
+ };
261
+ element.addEventListener(key, listener);
262
+ }
263
+ }
264
+ else if (isHTMLElemet(elementOrSelector)) {
265
+ let element = elementOrSelector;
241
266
  let listener = (event) => {
242
267
  if (interrupt(event, index)) {
243
- target.removeEventListener(key, listener);
268
+ element.removeEventListener(key, listener);
244
269
  }
245
270
  else {
246
271
  accept(event, index);
272
+ index++;
247
273
  }
248
274
  };
249
- target.addEventListener(key, listener);
275
+ element.addEventListener(key, listener);
250
276
  }
251
277
  }
252
278
  }
253
279
  catch (error) {
254
- throw new Error("Uncaught error as creating event semantic.");
280
+ console.error(error);
255
281
  }
256
282
  });
257
283
  }
@@ -260,34 +286,107 @@ export let event = (argument1, argument2) => {
260
286
  return new Semantic((accept, interrupt) => {
261
287
  try {
262
288
  let index = 0n;
263
- for (let target of targets) {
264
- if (isObject(target) && isFunction(Reflect.get(target, "addEventListener"))) {
289
+ for (let elementOrSelector of elementsOrSelectors) {
290
+ if (isString(elementOrSelector)) {
291
+ let element = window.document.querySelector(elementOrSelector);
292
+ if (validate(element)) {
293
+ for (let key of keys) {
294
+ if (isString(key)) {
295
+ let listener = (event) => {
296
+ if (interrupt(event, index)) {
297
+ element.removeEventListener(key, listener);
298
+ }
299
+ else {
300
+ accept(event, index);
301
+ index++;
302
+ }
303
+ };
304
+ element.addEventListener(key, listener);
305
+ }
306
+ }
307
+ }
308
+ }
309
+ else if (isHTMLElemet(elementOrSelector)) {
310
+ let element = elementOrSelector;
265
311
  for (let key of keys) {
266
312
  if (isString(key)) {
267
313
  let listener = (event) => {
268
314
  if (interrupt(event, index)) {
269
- target.removeEventListener(key, listener);
315
+ element.removeEventListener(key, listener);
270
316
  }
271
317
  else {
272
318
  accept(event, index);
273
319
  index++;
274
320
  }
275
321
  };
276
- target.addEventListener(key, listener);
322
+ element.addEventListener(key, listener);
277
323
  }
278
324
  }
279
325
  }
280
326
  }
281
327
  }
282
328
  catch (error) {
283
- throw new Error("Uncaught error as creating event semantic.");
329
+ console.error(error);
330
+ }
331
+ });
332
+ }
333
+ }
334
+ if (isHTMLElemet(argument1)) {
335
+ let element = argument1;
336
+ if (isString(argument2)) {
337
+ let key = argument2;
338
+ return new Semantic((accept, interrupt) => {
339
+ try {
340
+ let index = 0n;
341
+ let listener = (event) => {
342
+ if (interrupt(event, index)) {
343
+ element.removeEventListener(key, listener);
344
+ }
345
+ else {
346
+ accept(event, index);
347
+ index++;
348
+ }
349
+ };
350
+ element.addEventListener(key, listener);
351
+ }
352
+ catch (error) {
353
+ console.error(error);
354
+ }
355
+ });
356
+ }
357
+ if (isIterable(argument2)) {
358
+ let keys = argument2;
359
+ return new Semantic((accept, interrupt) => {
360
+ try {
361
+ let index = 0n;
362
+ for (let key of keys) {
363
+ if (isString(key)) {
364
+ let listener = (event) => {
365
+ if (interrupt(event, index)) {
366
+ element.removeEventListener(key, listener);
367
+ }
368
+ else {
369
+ accept(event, index);
370
+ index++;
371
+ }
372
+ };
373
+ element.addEventListener(key, listener);
374
+ }
375
+ }
376
+ }
377
+ catch (error) {
378
+ console.error(error);
284
379
  }
285
380
  });
286
381
  }
287
382
  }
288
383
  throw new TypeError("Invalid arguments.");
289
384
  };
290
- export let fill = (element, count) => {
385
+ export let useEmpty = () => {
386
+ return new Semantic(() => { });
387
+ };
388
+ ;
389
+ export let useFill = (element, count) => {
291
390
  if (validate(element) && count > 0n) {
292
391
  return new Semantic((accept, interrupt) => {
293
392
  try {
@@ -300,14 +399,14 @@ export let fill = (element, count) => {
300
399
  }
301
400
  }
302
401
  catch (error) {
303
- throw new Error("Uncaught error as creating fill semantic.");
402
+ console.error(error);
304
403
  }
305
404
  });
306
405
  }
307
406
  throw new TypeError("Invalid arguments.");
308
407
  };
309
408
  ;
310
- export let from = (iterable) => {
409
+ export let useFrom = (iterable) => {
311
410
  if (isIterable(iterable)) {
312
411
  return new Semantic((accept, interrupt) => {
313
412
  try {
@@ -321,7 +420,7 @@ export let from = (iterable) => {
321
420
  }
322
421
  }
323
422
  catch (error) {
324
- throw new Error("Uncaught error as creating from semantic.");
423
+ console.error(error);
325
424
  }
326
425
  });
327
426
  }
@@ -338,13 +437,14 @@ export let from = (iterable) => {
338
437
  }
339
438
  }
340
439
  catch (error) {
341
- throw new Error("Uncaught error as creating from semantic.");
440
+ console.error(error);
342
441
  }
343
442
  });
344
443
  }
345
444
  throw new TypeError("Invalid arguments");
346
445
  };
347
- export let generate = (supplier, interrupt) => {
446
+ ;
447
+ export let useGenerate = (supplier, interrupt) => {
348
448
  if (isFunction(supplier) && isFunction(interrupt)) {
349
449
  return new Semantic((accept, interrupt) => {
350
450
  try {
@@ -359,13 +459,14 @@ export let generate = (supplier, interrupt) => {
359
459
  }
360
460
  }
361
461
  catch (error) {
362
- throw new Error("Uncaught error as creating generate semantic.");
462
+ console.error(error);
363
463
  }
364
464
  });
365
465
  }
366
466
  throw new TypeError("Invalid arguments");
367
467
  };
368
- export let interval = (period, delay = 0) => {
468
+ ;
469
+ export let useInterval = (period, delay = 0) => {
369
470
  if (period > 0 && delay >= 0) {
370
471
  return new Semantic((accept, interrupt) => {
371
472
  try {
@@ -397,24 +498,24 @@ export let interval = (period, delay = 0) => {
397
498
  }
398
499
  }
399
500
  catch (error) {
400
- throw new Error("Uncaught error as creating interval semantic.");
501
+ console.error(error);
401
502
  }
402
503
  });
403
504
  }
404
505
  throw new TypeError("Invalid arguments.");
405
506
  };
406
- export let iterate = (generator) => {
507
+ export let useIterate = (generator) => {
407
508
  if (isFunction(generator)) {
408
509
  try {
409
510
  return new Semantic(generator);
410
511
  }
411
512
  catch (error) {
412
- throw new Error("Uncaught error as creating iterate semantic.");
513
+ console.error(error);
413
514
  }
414
515
  }
415
516
  throw new TypeError("Invalid arguments.");
416
517
  };
417
- export let promise = (promise) => {
518
+ export let usePromise = (promise) => {
418
519
  if (isPromise(promise)) {
419
520
  return new Semantic((accept, interrupt) => {
420
521
  try {
@@ -428,7 +529,7 @@ export let promise = (promise) => {
428
529
  });
429
530
  }
430
531
  catch (error) {
431
- throw new Error("Uncaught error as creating promise semantic.");
532
+ console.error(error);
432
533
  }
433
534
  });
434
535
  }
@@ -436,77 +537,188 @@ export let promise = (promise) => {
436
537
  throw new TypeError("Invalid arguments.");
437
538
  }
438
539
  };
439
- export let range = (start, end, step = 1) => {
440
- if ((!isNumber(step) && !isBigInt(step)) || (isNumber(step) && useCompare(step, 0) === 0) || (isBigInt(step) && useCompare(step, 0n) === 0)) {
441
- throw new TypeError("Step must be numeric and cannot be zero.");
442
- }
443
- if (isNumber(start) && isNumber(end)) {
444
- let minimum = start, maximum = end, limit = Number(step);
445
- let condition = limit > 0 ? (i) => i < maximum : (i) => i > maximum;
540
+ ;
541
+ export let useOf = (...target) => {
542
+ if (Array.isArray(target)) {
446
543
  return new Semantic((accept, interrupt) => {
447
544
  try {
448
- for (let i = minimum; condition(i); i += limit) {
449
- let value = i;
450
- if (interrupt(value, BigInt(i))) {
545
+ let index = 0n;
546
+ for (let element of target) {
547
+ if (interrupt(element, index)) {
451
548
  break;
452
549
  }
453
- accept(value, BigInt(i));
550
+ accept(element, index);
551
+ index++;
454
552
  }
455
553
  }
456
554
  catch (error) {
457
- throw new Error("Uncaught error as creating range semantic.");
555
+ console.error(error);
458
556
  }
459
557
  });
460
558
  }
461
559
  throw new TypeError("Invalid arguments.");
462
560
  };
463
- export let websocket = (websocket) => {
464
- if (invalidate(websocket)) {
465
- throw new TypeError("WebSocket is invalid.");
561
+ ;
562
+ export let useRange = (start, end, step = (isNumber(start) && isNumber(end) ? 1 : 1n)) => {
563
+ if ((!isNumber(step) && !isBigInt(step)) || (isNumber(step) && useCompare(step, 0) === 0) || (isBigInt(step) && useCompare(step, 0n) === 0)) {
564
+ throw new TypeError("Step must be numeric and cannot be zero.");
466
565
  }
467
- return new Semantic((accept, interrupt) => {
468
- try {
469
- let index = 0n;
470
- let stop = false;
471
- websocket.addEventListener("open", (event) => {
472
- if (stop || interrupt(event, index)) {
473
- stop = true;
474
- }
475
- else {
476
- accept(event, index);
566
+ if (isNumber(start) && isNumber(end)) {
567
+ let trusted = useToNumber(step);
568
+ return new Semantic((accept, interrupt) => {
569
+ try {
570
+ let index = 0n;
571
+ for (let i = start; i < end; i += trusted) {
572
+ if (interrupt(i, index)) {
573
+ break;
574
+ }
575
+ accept(i, index);
477
576
  index++;
478
577
  }
479
- });
480
- websocket.addEventListener("message", (event) => {
481
- if (stop || interrupt(event, index)) {
482
- stop = true;
483
- }
484
- else {
485
- accept(event, index);
578
+ }
579
+ catch (error) {
580
+ console.error(error);
581
+ }
582
+ });
583
+ }
584
+ else if (isBigInt(start) && isBigInt(end)) {
585
+ let trusted = useToBigInt(step);
586
+ return new Semantic((accept, interrupt) => {
587
+ try {
588
+ let index = 0n;
589
+ for (let i = start; i < end; i += trusted) {
590
+ if (interrupt(i, index)) {
591
+ break;
592
+ }
593
+ accept(i, index);
486
594
  index++;
487
595
  }
488
- });
489
- websocket.addEventListener("error", (event) => {
490
- if (stop || interrupt(event, index)) {
491
- stop = true;
596
+ }
597
+ catch (error) {
598
+ console.error(error);
599
+ }
600
+ });
601
+ }
602
+ throw new TypeError("Invalid arguments.");
603
+ };
604
+ ;
605
+ export let useWebSocket = (argument1, argument2) => {
606
+ if (isObject(argument1) && isFunction(Reflect.get(argument1, "addEventListener"))) {
607
+ let websocket = argument1;
608
+ if (isString(argument2)) {
609
+ let key = argument2;
610
+ return new Semantic((accept, interrupt) => {
611
+ try {
612
+ let listener = (event) => {
613
+ if (interrupt(event, 0n)) {
614
+ websocket.removeEventListener(key, listener);
615
+ }
616
+ else {
617
+ accept(event, 0n);
618
+ }
619
+ };
620
+ websocket.addEventListener(key, listener);
492
621
  }
493
- else {
494
- accept(event, index);
495
- index++;
622
+ catch (error) {
623
+ console.error(error);
496
624
  }
497
625
  });
498
- websocket.addEventListener("close", (event) => {
499
- if (stop || interrupt(event, index)) {
500
- stop = true;
626
+ }
627
+ else if (isIterable(argument2)) {
628
+ let keys = argument2;
629
+ return new Semantic((accept, interrupt) => {
630
+ try {
631
+ for (let key of keys) {
632
+ if (isString(key)) {
633
+ let listener = (event) => {
634
+ if (interrupt(event, 0n)) {
635
+ websocket.removeEventListener(key, listener);
636
+ }
637
+ else {
638
+ accept(event, 0n);
639
+ }
640
+ };
641
+ websocket.addEventListener(key, listener);
642
+ }
643
+ }
501
644
  }
502
- else {
503
- accept(event, index);
504
- index++;
645
+ catch (error) {
646
+ console.error(error);
505
647
  }
506
648
  });
507
649
  }
508
- catch (error) {
509
- throw new Error("Uncaught error as creating websocket semantic.");
510
- }
511
- });
650
+ let keys = ["open", "message", "close", "error"];
651
+ return new Semantic((accept, interrupt) => {
652
+ try {
653
+ for (let key of keys) {
654
+ let listener = (event) => {
655
+ if (interrupt(event, 0n)) {
656
+ websocket.removeEventListener(key, listener);
657
+ }
658
+ else {
659
+ accept(event, 0n);
660
+ }
661
+ };
662
+ websocket.addEventListener(key, listener);
663
+ }
664
+ }
665
+ catch (error) {
666
+ console.error(error);
667
+ }
668
+ });
669
+ }
670
+ throw new TypeError("Invalid arguments.");
671
+ };
672
+ ;
673
+ export let useWindow = (argument1) => {
674
+ if (isString(argument1)) {
675
+ let key = argument1;
676
+ return new Semantic((accept, interrupt) => {
677
+ try {
678
+ let listener = (event) => {
679
+ if (interrupt(event, 0n)) {
680
+ window.removeEventListener(key, listener);
681
+ }
682
+ else {
683
+ console.log(event.type, event);
684
+ accept(event, 0n);
685
+ }
686
+ };
687
+ window.addEventListener(key, listener);
688
+ }
689
+ catch (error) {
690
+ console.error(error);
691
+ }
692
+ });
693
+ }
694
+ else if (isIterable(argument1)) {
695
+ let keys = new Set(argument1);
696
+ return new Semantic((accept, interrupt) => {
697
+ try {
698
+ let index = 0n;
699
+ for (let key of keys) {
700
+ if (isString(key)) {
701
+ let listener = function (event) {
702
+ if (interrupt(event, index)) {
703
+ console.log("Terminal", performance.now());
704
+ window.removeEventListener(key, listener);
705
+ }
706
+ else {
707
+ console.log("accept", performance.now());
708
+ accept(event, index);
709
+ }
710
+ };
711
+ index++;
712
+ window.addEventListener(key, listener);
713
+ }
714
+ }
715
+ }
716
+ catch (error) {
717
+ console.error(error);
718
+ }
719
+ });
720
+ }
721
+ throw new TypeError("Invalid arguments.");
512
722
  };
723
+ export let useNullable = (target) => Optional.ofNullable(target);
724
+ export let useNonNull = (target) => Optional.ofNonNull(target);