1 | function* accumulate(x, fr, acc) {
|
2 | var init = arguments.length <= 2, i = -1;
|
3 | for (var v of x) {
|
4 | if (init) {
|
5 | acc = v;
|
6 | init = false;
|
7 | ++i;
|
8 | }
|
9 | else
|
10 | acc = fr(acc, v, ++i, x);
|
11 | yield acc;
|
12 | }
|
13 | }
|
14 | function callable(x) {
|
15 | var xi = x[Symbol.iterator]();
|
16 | return () => xi.next().value;
|
17 | }
|
18 | function is(v) {
|
19 | return v != null && typeof v[Symbol.iterator] === "function";
|
20 | }
|
21 | function isOnce(v) {
|
22 | return is(v) && v[Symbol.iterator]() === v;
|
23 | }
|
24 | function manyLate(x, a) {
|
25 | return { [Symbol.iterator]: () => {
|
26 | var i = 0, xi = x[Symbol.iterator]();
|
27 | return { next: () => {
|
28 | if (i < a.length)
|
29 | return { value: a[i++], done: false };
|
30 | var { value, done } = xi.next();
|
31 | if (!done)
|
32 | a[i++] = value;
|
33 | return { value, done };
|
34 | } };
|
35 | } };
|
36 | }
|
37 | function many(x, now = false) {
|
38 | if (!isOnce(x))
|
39 | return x;
|
40 | return now ? Array.from(x) : manyLate(x, []);
|
41 | }
|
42 | function id(v) {
|
43 | return v;
|
44 | }
|
45 | function* cartesianProduct(xs, fm = null) {
|
46 | var fm = fm || id;
|
47 | var X = xs.length;
|
48 | if (X === 0)
|
49 | return;
|
50 | var is = [], os = [];
|
51 | for (var i = 0; i < X; i++) {
|
52 | xs[i] = i > 0 ? many(xs[i]) : xs[i];
|
53 | is[i] = xs[i][Symbol.iterator]();
|
54 | os[i] = is[i].next();
|
55 | if (os[i].done)
|
56 | return;
|
57 | }
|
58 | for (var i = 0;; i++) {
|
59 | var vs = [];
|
60 | for (var o of os)
|
61 | vs.push(o.value);
|
62 | yield fm(vs, i, null);
|
63 | for (var r = X - 1; r >= 0; r--) {
|
64 | os[r] = is[r].next();
|
65 | if (!os[r].done)
|
66 | break;
|
67 | is[r] = xs[r][Symbol.iterator]();
|
68 | os[r] = is[r].next();
|
69 | }
|
70 | if (r < 0)
|
71 | break;
|
72 | }
|
73 | }
|
74 | function* chunk(x, n = 1, s = n) {
|
75 | var M = Math.max(n, s);
|
76 | var m = 0, a = [];
|
77 | for (var v of x) {
|
78 | if (m < n)
|
79 | a.push(v);
|
80 | if (++m < M)
|
81 | continue;
|
82 | yield a;
|
83 | a = a.slice(s);
|
84 | m = a.length;
|
85 | }
|
86 | if (a.length > 0)
|
87 | yield a;
|
88 | }
|
89 | function cmp(a, b) {
|
90 | return a < b ? -1 : (a > b ? 1 : 0);
|
91 | }
|
92 | function compare(x, y, fc = null, fm = null) {
|
93 | var fc = fc || cmp, fm = fm || id;
|
94 | var ix = x[Symbol.iterator]();
|
95 | var iy = y[Symbol.iterator]();
|
96 | for (var i = 0;; i++) {
|
97 | var u = ix.next();
|
98 | var v = iy.next();
|
99 | if (u.done || v.done)
|
100 | break;
|
101 | var u1 = fm(u.value, i, x);
|
102 | var v1 = fm(v.value, i, y);
|
103 | var c = fc(u1, v1);
|
104 | if (c !== 0)
|
105 | return c;
|
106 | }
|
107 | return (v.done ? 1 : 0) - (u.done ? 1 : 0);
|
108 | }
|
109 | function* concat(...xs) {
|
110 | for (var x of xs)
|
111 | yield* x;
|
112 | }
|
113 | const END = Number.MAX_SAFE_INTEGER;
|
114 | function* slicePos(x, i, I) {
|
115 | var k = -1;
|
116 | for (var v of x) {
|
117 | if (++k >= I)
|
118 | break;
|
119 | if (k >= i)
|
120 | yield v;
|
121 | }
|
122 | }
|
123 | function* slicePosNeg(x, i, I) {
|
124 | var j = 0, k = -1;
|
125 | var a = [], A = -I;
|
126 | for (var v of x) {
|
127 | if (++k < i)
|
128 | continue;
|
129 | if (a.length >= A)
|
130 | yield a[j];
|
131 | a[j] = v;
|
132 | j = (j + 1) % A;
|
133 | }
|
134 | }
|
135 | function* sliceNeg(x, i, I) {
|
136 | var j = 0, n = 0;
|
137 | var a = [], A = -i;
|
138 | for (var v of x) {
|
139 | a[j] = v;
|
140 | j = (j + 1) % A;
|
141 | n++;
|
142 | }
|
143 | if (n < A)
|
144 | return;
|
145 | var I = I < 0 ? I : Math.min(I - n, 0);
|
146 | var n = Math.max(I - i, 0);
|
147 | var J = Math.max(j + n - A, 0);
|
148 | yield* a.slice(j, j + n);
|
149 | yield* a.slice(0, J);
|
150 | }
|
151 | function* slice(x, i = 0, I = END) {
|
152 | if (i >= 0 && I >= 0)
|
153 | yield* slicePos(x, i, I);
|
154 | else if (i >= 0 && I < 0)
|
155 | yield* slicePosNeg(x, i, I);
|
156 | else
|
157 | yield* sliceNeg(x, i, I);
|
158 | }
|
159 | function* copy(x, y, j = 0, i = 0, I = END) {
|
160 | var k = -1, J = -1;
|
161 | for (var u of x) {
|
162 | if (++k === j) {
|
163 | J = k;
|
164 | for (var v of slice(y, i, I)) {
|
165 | yield v;
|
166 | ++J;
|
167 | }
|
168 | }
|
169 | if (k >= j && k < J)
|
170 | continue;
|
171 | else
|
172 | yield u;
|
173 | }
|
174 | if (k < j) {
|
175 | for (; ++k < j;)
|
176 | yield undefined;
|
177 | yield* slice(y, i, I);
|
178 | }
|
179 | }
|
180 | function size(x, i = 0, I = END) {
|
181 | var j = -1, n = 0;
|
182 | for (var _ of x)
|
183 | if (++j >= i && j < I)
|
184 | n++;
|
185 | return n;
|
186 | }
|
187 | function* copyWithin(x, j = 0, i = 0, I = END) {
|
188 | var x = many(x), n = size(x);
|
189 | for (var v of copy(x, x, j, i, I)) {
|
190 | if (--n < 0)
|
191 | break;
|
192 | yield v;
|
193 | }
|
194 | }
|
195 | function id$1(v) {
|
196 | return v;
|
197 | }
|
198 | function cmp$1(a, b) {
|
199 | return a < b ? -1 : (a > b ? 1 : 0);
|
200 | }
|
201 | function count(x, ft) {
|
202 | var a = 0, i = -1;
|
203 | for (var v of x)
|
204 | if (ft(v, ++i, x))
|
205 | a++;
|
206 | return a;
|
207 | }
|
208 | function countAs(x, fm = null) {
|
209 | var fm = fm || id$1;
|
210 | var a = new Map(), i = -1;
|
211 | for (var v of x) {
|
212 | var v1 = fm(v, ++i, x);
|
213 | a.set(v1, (a.get(v1) || 0) + 1);
|
214 | }
|
215 | return a;
|
216 | }
|
217 | function from$(x) {
|
218 | return Array.isArray(x) ? x : [...x];
|
219 | }
|
220 | function from(vs, fm = null) {
|
221 | return new Set(fm ? from$(vs).map(fm) : vs);
|
222 | }
|
223 | function scanUntil(x, ft) {
|
224 | var i = -1;
|
225 | for (var v of x)
|
226 | if (ft(v, ++i, x))
|
227 | return i;
|
228 | return ++i;
|
229 | }
|
230 | function from$$1(x) {
|
231 | return Array.isArray(x) ? x : [...x];
|
232 | }
|
233 | function searchValue(x, v, fc = null, fm = null) {
|
234 | var fc = fc || cmp$1, fm = fm || id$1;
|
235 | var v1 = fm(v, 0, null), i = -1;
|
236 | for (var u of x) {
|
237 | var u1 = fm(u, ++i, x);
|
238 | if (fc(u1, v1) === 0)
|
239 | return i;
|
240 | }
|
241 | return -1;
|
242 | }
|
243 | function isDisjointMap(x, y, fm = null) {
|
244 | var s = from(y, fm);
|
245 | var fm = fm || id$1, i = -1;
|
246 | for (var u of x) {
|
247 | var u1 = fm(u, ++i, x);
|
248 | if (s.has(u1))
|
249 | return false;
|
250 | }
|
251 | return true;
|
252 | }
|
253 | function isDisjointDual(x, y, fc = null, fm = null) {
|
254 | var fc = fc || cmp$1, fm = fm || id$1;
|
255 | var y1 = [...y].map(fm), i = -1;
|
256 | for (var u of x) {
|
257 | var u1 = fm(u, ++i, x);
|
258 | for (var v1 of y1)
|
259 | if (fc(u1, v1) === 0)
|
260 | return false;
|
261 | }
|
262 | return true;
|
263 | }
|
264 | function isDisjoint(x, y, fc = null, fm = null) {
|
265 | if (fc)
|
266 | return isDisjointDual(x, y, fc, fm);
|
267 | return isDisjointMap(x, y, fm);
|
268 | }
|
269 | function isUniqueMap(x, fm = null) {
|
270 | var fm = fm || id$1;
|
271 | var s = new Set(), i = -1;
|
272 | for (var v of x) {
|
273 | var v1 = fm(v, ++i, x);
|
274 | if (s.has(v1))
|
275 | return false;
|
276 | s.add(v1);
|
277 | }
|
278 | return true;
|
279 | }
|
280 | function isUniqueDual(x, fc = null, fm = null) {
|
281 | var fc = fc || cmp$1, fm = fm || id$1;
|
282 | var x1 = [...x].map(fm);
|
283 | for (var u1 of x1) {
|
284 | for (var v1 of x1)
|
285 | if (fc(u1, v1) === 0)
|
286 | return false;
|
287 | }
|
288 | return true;
|
289 | }
|
290 | function isUnique(x, fc = null, fm = null) {
|
291 | if (fc)
|
292 | return isUniqueDual(x, fc, fm);
|
293 | else
|
294 | return isUniqueMap(x, fm);
|
295 | }
|
296 | function range(x, fc = null, fm = null) {
|
297 | var fc = fc || cmp$1, fm = fm || id$1;
|
298 | var mi = -1, mu, mv;
|
299 | var ni = -1, nu, nv;
|
300 | var i = -1;
|
301 | for (var u of x) {
|
302 | var v = fm(u, ++i, x);
|
303 | if (i === 0 || fc(v, mv) < 0) {
|
304 | mi = i;
|
305 | mu = u;
|
306 | mv = v;
|
307 | }
|
308 | if (i === 0 || fc(v, nv) > 0) {
|
309 | ni = i;
|
310 | nu = u;
|
311 | nv = v;
|
312 | }
|
313 | }
|
314 | return [[mi, mu], [ni, nu]];
|
315 | }
|
316 | function partition(x, ft) {
|
317 | var t = [], f = [], i = -1;
|
318 | for (var v of x) {
|
319 | if (ft(v, ++i, x))
|
320 | t.push(v);
|
321 | else
|
322 | f.push(v);
|
323 | }
|
324 | return [t, f];
|
325 | }
|
326 | function partitionAs(x, fm = null) {
|
327 | var fm = fm || id$1;
|
328 | var a = new Map(), i = -1;
|
329 | for (var v of x) {
|
330 | var v1 = fm(v, ++i, x);
|
331 | if (!a.has(v1))
|
332 | a.set(v1, []);
|
333 | a.get(v1).push(v);
|
334 | }
|
335 | return a;
|
336 | }
|
337 | function scanWhile(x, ft) {
|
338 | var i = -1;
|
339 | for (var v of x)
|
340 | if (!ft(v, ++i, x))
|
341 | return i;
|
342 | return ++i;
|
343 | }
|
344 | function count$1(x, ft) {
|
345 | return count(x, ft);
|
346 | }
|
347 | function countAs$1(x, fm = null) {
|
348 | return countAs(x, fm);
|
349 | }
|
350 | function* cut(x, ft) {
|
351 | var i = -1, a = [];
|
352 | for (var v of x) {
|
353 | if (ft(v, ++i, x)) {
|
354 | yield a;
|
355 | a = [];
|
356 | }
|
357 | a.push(v);
|
358 | }
|
359 | yield a;
|
360 | }
|
361 | function* cutAt(x, is) {
|
362 | var ii = is[Symbol.iterator]();
|
363 | var { value, done } = ii.next();
|
364 | if (done)
|
365 | value = END;
|
366 | var a = [], j = -1;
|
367 | for (var v of x) {
|
368 | if (++j < value) {
|
369 | a.push(v);
|
370 | continue;
|
371 | }
|
372 | yield a;
|
373 | a = [v];
|
374 | var { value, done } = ii.next();
|
375 | if (done)
|
376 | value = END;
|
377 | }
|
378 | yield a;
|
379 | for (; !done; { done } = ii.next())
|
380 | yield [];
|
381 | }
|
382 | function* map(x, fm) {
|
383 | var i = -1;
|
384 | for (var v of x)
|
385 | yield fm(v, ++i, x);
|
386 | }
|
387 | function* cutAtRight(x, is) {
|
388 | yield* cutAt(x, map(is, i => i + 1));
|
389 | }
|
390 | function* cutRight(x, ft) {
|
391 | var i = -1, a = [];
|
392 | for (var v of x) {
|
393 | a.push(v);
|
394 | if (ft(v, ++i, x)) {
|
395 | yield a;
|
396 | a = [];
|
397 | }
|
398 | }
|
399 | yield a;
|
400 | }
|
401 | function mod(x, y) {
|
402 | return x - y * Math.floor(x / y);
|
403 | }
|
404 | function* cycle(x, i = 0, n = -1) {
|
405 | var x = many(x);
|
406 | var i = i === 0 ? 0 : mod(i, size(x));
|
407 | while (true) {
|
408 | for (var v of x) {
|
409 | if (--i >= 0)
|
410 | continue;
|
411 | if (n-- === 0)
|
412 | return;
|
413 | yield v;
|
414 | }
|
415 | }
|
416 | }
|
417 | function from$$1$1(x) {
|
418 | return Array.isArray(x) ? x : [...x];
|
419 | }
|
420 | function from$1(vs, fm = null) {
|
421 | return new Set(fm ? from$$1$1(vs).map(fm) : vs);
|
422 | }
|
423 | function* differenceMap(x, y, fm = null) {
|
424 | var s = from$1(y, fm);
|
425 | var fm = fm || id, i = -1;
|
426 | for (var u of x) {
|
427 | var u1 = fm(u, ++i, x);
|
428 | if (!s.has(u1))
|
429 | yield u;
|
430 | }
|
431 | }
|
432 | function* differenceDual(x, y, fc = null, fm = null) {
|
433 | var fc = fc || cmp, fm = fm || id;
|
434 | var y1 = [...y].map(fm), i = -1;
|
435 | x: for (var u of x) {
|
436 | var u1 = fm(u, ++i, x);
|
437 | for (var v1 of y1)
|
438 | if (fc(u1, v1) === 0)
|
439 | continue x;
|
440 | yield u;
|
441 | }
|
442 | }
|
443 | function* difference(x, y, fc = null, fm = null) {
|
444 | if (fc)
|
445 | yield* differenceDual(x, y, fc, fm);
|
446 | else
|
447 | yield* differenceMap(x, y, fm);
|
448 | }
|
449 | function* drop(x, n = 1) {
|
450 | yield* slice(x, n);
|
451 | }
|
452 | function* dropRight(x, n = 1) {
|
453 | if (n > 0)
|
454 | yield* slice(x, 0, -n);
|
455 | else
|
456 | yield* x;
|
457 | }
|
458 | function* dropWhile(x, ft) {
|
459 | var c = true, i = -1;
|
460 | for (var v of x) {
|
461 | c = c && ft(v, ++i, x);
|
462 | if (!c)
|
463 | yield v;
|
464 | }
|
465 | }
|
466 | function* dropWhileRight(x, ft) {
|
467 | var i = -1, a = [];
|
468 | for (var v of x) {
|
469 | if (ft(v, ++i, x))
|
470 | a.push(v);
|
471 | else {
|
472 | yield* a;
|
473 | yield v;
|
474 | a.length = 0;
|
475 | }
|
476 | }
|
477 | }
|
478 | function* entries(x) {
|
479 | var i = -1;
|
480 | for (var v of x)
|
481 | yield [++i, v];
|
482 | }
|
483 | function everyBool(x) {
|
484 | for (var v of x)
|
485 | if (!v)
|
486 | return false;
|
487 | return true;
|
488 | }
|
489 | function everyTest(x, ft) {
|
490 | var i = -1;
|
491 | for (var v of x)
|
492 | if (!ft(v, ++i, x))
|
493 | return false;
|
494 | return true;
|
495 | }
|
496 | function every(x, ft = null) {
|
497 | if (ft)
|
498 | return everyTest(x, ft);
|
499 | else
|
500 | return everyBool(x);
|
501 | }
|
502 | function* fill(x, v, i = 0, I = END) {
|
503 | var j = -1;
|
504 | for (var u of x) {
|
505 | if (++j >= i && j < I)
|
506 | yield v;
|
507 | else
|
508 | yield u;
|
509 | }
|
510 | }
|
511 | function* filter(x, ft) {
|
512 | var i = -1;
|
513 | for (var v of x)
|
514 | if (ft(v, ++i, x))
|
515 | yield v;
|
516 | }
|
517 | function* filterAt(x, is) {
|
518 | var i = -1;
|
519 | for (var v of x)
|
520 | if (is.includes(++i))
|
521 | yield v;
|
522 | }
|
523 | function find(x, ft) {
|
524 | var i = -1;
|
525 | for (var v of x)
|
526 | if (ft(v, ++i, x))
|
527 | return v;
|
528 | }
|
529 | function* findAll(x, ft) {
|
530 | yield* filter(x, ft);
|
531 | }
|
532 | function findRight(x, ft) {
|
533 | var i = -1, a;
|
534 | for (var v of x)
|
535 | if (ft(v, ++i, x))
|
536 | a = v;
|
537 | return a;
|
538 | }
|
539 | function isList(v) {
|
540 | return is(v) && typeof v !== "string";
|
541 | }
|
542 | function* flat(x, n = -1, fm = null, ft = null) {
|
543 | var fm = fm || id, ft = ft || isList, i = -1;
|
544 | for (var v of x) {
|
545 | var v1 = fm(v, ++i, x);
|
546 | if (n !== 0 && ft(v1, i, x))
|
547 | yield* flat(v1, n - 1, fm, ft);
|
548 | else
|
549 | yield v1;
|
550 | }
|
551 | }
|
552 | function* flatMap(x, fm = null, ft = null) {
|
553 | var fm = fm || id, ft = ft || isList, i = -1;
|
554 | for (var v of x) {
|
555 | var v1 = fm(v, ++i, x);
|
556 | if (ft(v1, i, x))
|
557 | yield* v1;
|
558 | else
|
559 | yield v1;
|
560 | }
|
561 | }
|
562 | function forEach(x, fc) {
|
563 | var i = -1;
|
564 | for (var v of x)
|
565 | fc(v, ++i, x);
|
566 | }
|
567 | function from$2(x) {
|
568 | if (typeof x[Symbol.iterator] === "function")
|
569 | return x;
|
570 | return { [Symbol.iterator]: () => x };
|
571 | }
|
572 | function* fromApply(fm = null, v, n = -1) {
|
573 | if (n !== 0)
|
574 | yield v;
|
575 | for (var i = 1; i !== n; i++)
|
576 | yield (v = fm(v, i, null));
|
577 | }
|
578 | function* fromCall(fc, ...as) {
|
579 | for (;;)
|
580 | yield fc(...as);
|
581 | }
|
582 | function* fromRange(v = 0, V = END, s = 1) {
|
583 | if (s >= 0) {
|
584 | for (; v < V; v += s)
|
585 | yield v;
|
586 | }
|
587 | else {
|
588 | for (; v > V; v += s)
|
589 | yield v;
|
590 | }
|
591 | }
|
592 | function get(x, i) {
|
593 | var j = -1;
|
594 | for (var v of x)
|
595 | if (++j === i)
|
596 | return v;
|
597 | }
|
598 | function* getAll(x, is) {
|
599 | var ii = is[Symbol.iterator]();
|
600 | var value = -1, j = -1;
|
601 | for (var v of x) {
|
602 | while (value <= j) {
|
603 | var { value, done } = ii.next();
|
604 | if (done)
|
605 | return;
|
606 | if (value <= j)
|
607 | yield undefined;
|
608 | }
|
609 | if (value === ++j)
|
610 | yield v;
|
611 | }
|
612 | while (!ii.next().done)
|
613 | yield undefined;
|
614 | }
|
615 | function getPath(x, p) {
|
616 | for (var i of p)
|
617 | x = is(x) ? get(x, i) : undefined;
|
618 | return x;
|
619 | }
|
620 | function* group(x, fc = null, fm = null) {
|
621 | var fc = fc || cmp, fm = fm || id;
|
622 | var a = [], u1, i = -1;
|
623 | for (var v of x) {
|
624 | var v1 = fm(v, ++i, x);
|
625 | if (i > 0 && fc(u1, v1) !== 0) {
|
626 | yield a;
|
627 | a = [v];
|
628 | }
|
629 | else
|
630 | a.push(v);
|
631 | u1 = v1;
|
632 | }
|
633 | yield a;
|
634 | }
|
635 | function head(x, vd) {
|
636 | for (var v of x)
|
637 | return v;
|
638 | return vd;
|
639 | }
|
640 | function* searchInfixAll(x, y, fc, fm = null) {
|
641 | var fc = fc || cmp, fm = fm || id;
|
642 | var y1 = from$$1(y), Y = y1.length;
|
643 | if (Y === 0)
|
644 | yield 0;
|
645 | var y1 = y1.map(fm, null);
|
646 | var m = new Array(Y).fill(false);
|
647 | var i = -1, J = 0;
|
648 | for (var u of x) {
|
649 | var u1 = fm(u, ++i, x);
|
650 | for (var j = J; j > 0; j--)
|
651 | m[j] = m[j - 1] && fc(u1, y1[j]) === 0;
|
652 | m[0] = fc(u1, y1[0]) === 0;
|
653 | J = Math.min(J + 1, Y - 1);
|
654 | if (m[Y - 1])
|
655 | yield i - Y + 1;
|
656 | }
|
657 | }
|
658 | function searchInfix(x, y, fc, fm = null) {
|
659 | return head(searchInfixAll(x, y, fc, fm), -1);
|
660 | }
|
661 | function hasInfix(x, y, fc, fm = null) {
|
662 | return searchInfix(x, y, fc, fm) >= 0;
|
663 | }
|
664 | function hasPath(x, p) {
|
665 | return getPath(x, p) !== undefined;
|
666 | }
|
667 | function hasPrefix(x, y, fc = null, fm = null) {
|
668 | var fc = fc || cmp, fm = fm || id;
|
669 | var ix = x[Symbol.iterator](), i = -1;
|
670 | for (var v of y) {
|
671 | var { value, done } = ix.next();
|
672 | if (done)
|
673 | return false;
|
674 | var u1 = fm(value, ++i, x);
|
675 | var v1 = fm(v, i, y);
|
676 | if (fc(u1, v1) !== 0)
|
677 | return false;
|
678 | }
|
679 | return true;
|
680 | }
|
681 | function searchSubsequence(x, y, fc = null, fm = null) {
|
682 | var fc = fc || cmp, fm = fm || id;
|
683 | var iy = y[Symbol.iterator]();
|
684 | var { value, done } = iy.next();
|
685 | if (done)
|
686 | return 0;
|
687 | var i = -1, j = -1, a = -1;
|
688 | var v1 = fm(value, ++j, y);
|
689 | for (var u of x) {
|
690 | var u1 = fm(u, ++i, x);
|
691 | if (fc(u1, v1) !== 0)
|
692 | continue;
|
693 | if (a < 0)
|
694 | a = i;
|
695 | var { value, done } = iy.next();
|
696 | if (done)
|
697 | return a;
|
698 | v1 = fm(value, ++j, y);
|
699 | }
|
700 | return -1;
|
701 | }
|
702 | function hasSubsequence(x, y, fc = null, fm = null) {
|
703 | return searchSubsequence(x, y, fc, fm) >= 0;
|
704 | }
|
705 | function hasSuffix(x, y, fc, fm = null) {
|
706 | var fc = fc || cmp, fm = fm || id;
|
707 | var y1 = from$$1(y), Y = y1.length;
|
708 | var a = [], ai = 0, n = 0;
|
709 | if (Y === 0)
|
710 | return true;
|
711 | for (var u of x) {
|
712 | a[ai++ % Y] = u;
|
713 | n++;
|
714 | }
|
715 | if (a.length < Y)
|
716 | return false;
|
717 | for (var i = 0, j = n - Y; i < Y; i++, j++) {
|
718 | var u1 = fm(a[ai++ % Y], j, x);
|
719 | var v1 = fm(y1[i], i, y);
|
720 | if (fc(u1, v1) !== 0)
|
721 | return false;
|
722 | }
|
723 | return true;
|
724 | }
|
725 | function searchValue$1(x, v, fc = null, fm = null) {
|
726 | return searchValue(x, v, fc, fm);
|
727 | }
|
728 | function hasValue(x, v, fc = null, fm = null) {
|
729 | return searchValue$1(x, v, fc, fm) >= 0;
|
730 | }
|
731 | function includes(x, v, i = 0) {
|
732 | return hasValue(slice(x, i), v);
|
733 | }
|
734 | function index(x, i = 0) {
|
735 | var n = size(x);
|
736 | return i < 0 ? Math.max(n + i, 0) : Math.min(i, n);
|
737 | }
|
738 | function indexOf(x, v, i = 0) {
|
739 | var a = searchValue$1(slice(x, i), v);
|
740 | return a < 0 ? a : a + i;
|
741 | }
|
742 | function indexRange(x, i = 0, I = END) {
|
743 | var n = size(x);
|
744 | i = i < 0 ? Math.max(n + i, 0) : Math.min(i, n);
|
745 | I = I < 0 ? Math.max(n + I, 0) : Math.min(I, n);
|
746 | I = Math.max(i, I);
|
747 | return [i, I];
|
748 | }
|
749 | function* init(x) {
|
750 | var u, i = -1;
|
751 | for (var v of x) {
|
752 | if (++i > 0)
|
753 | yield u;
|
754 | u = v;
|
755 | }
|
756 | }
|
757 | function* interleave(xs) {
|
758 | var X = xs.length;
|
759 | var is = [], os = [];
|
760 | for (var n = 0, i = 0; n < X; n++) {
|
761 | is[i] = xs[i][Symbol.iterator]();
|
762 | os[i] = is[i].next();
|
763 | if (!os[i].done)
|
764 | i++;
|
765 | }
|
766 | for (var j = 0; i > 0; j++) {
|
767 | var vs = os.map(o => o.value);
|
768 | j %= i;
|
769 | yield vs[j];
|
770 | os[j] = is[j].next();
|
771 | if (!os[j].done)
|
772 | continue;
|
773 | is.splice(j, 1);
|
774 | os.splice(j, 1);
|
775 | i--;
|
776 | }
|
777 | }
|
778 | function* repeat(x, n = -1) {
|
779 | var x = many(x);
|
780 | for (; n !== 0; n--)
|
781 | yield* x;
|
782 | }
|
783 | function* intermix(x, y, m = 1, n = 1, s = m, t = n) {
|
784 | var x1 = chunk(x, m, s);
|
785 | var y1 = chunk(repeat(y), n, t);
|
786 | var iy = y1[Symbol.iterator](), i = -1;
|
787 | for (var u of x1) {
|
788 | if (++i > 0)
|
789 | yield* iy.next().value;
|
790 | yield* u;
|
791 | }
|
792 | }
|
793 | function* interpolate(x, fc) {
|
794 | var u, i = -1;
|
795 | for (var v of x) {
|
796 | if (++i > 0)
|
797 | yield fc(u, v);
|
798 | yield (u = v);
|
799 | }
|
800 | }
|
801 | function* intersectionMap(x, y, fm = null) {
|
802 | var s = from$1(y, fm);
|
803 | var fm = fm || id, i = -1;
|
804 | for (var u of x) {
|
805 | var u1 = fm(u, ++i, x);
|
806 | if (s.has(u1))
|
807 | yield u;
|
808 | }
|
809 | }
|
810 | function* intersectionDual(x, y, fc = null, fm = null) {
|
811 | var fc = fc || cmp, fm = fm || id;
|
812 | var y1 = [...y].map(fm), i = -1;
|
813 | x: for (var u of x) {
|
814 | var u1 = fm(u, ++i, x);
|
815 | for (var v1 of y1)
|
816 | if (fc(u1, v1) === 0) {
|
817 | yield u;
|
818 | continue x;
|
819 | }
|
820 | }
|
821 | }
|
822 | function* intersection(x, y, fc = null, fm = null) {
|
823 | if (fc)
|
824 | yield* intersectionDual(x, y, fc, fm);
|
825 | else
|
826 | yield* intersectionMap(x, y, fm);
|
827 | }
|
828 | function* intersperse(x, v) {
|
829 | var i = -1;
|
830 | for (var u of x) {
|
831 | if (++i > 0)
|
832 | yield v;
|
833 | yield u;
|
834 | }
|
835 | }
|
836 | function isDisjoint$1(x, y, fc = null, fm = null) {
|
837 | return isDisjoint(x, y, fc, fm);
|
838 | }
|
839 | function isEmpty(x) {
|
840 | for (var _ of x)
|
841 | return false;
|
842 | return true;
|
843 | }
|
844 | function isEqual(x, y, fc = null, fm = null) {
|
845 | return compare(x, y, fc, fm) === 0;
|
846 | }
|
847 | function isIterator(v) {
|
848 | return v != null && typeof v.next === "function";
|
849 | }
|
850 | function isMany(v) {
|
851 | return !isOnce(v);
|
852 | }
|
853 | function isUnique$1(x, fc = null, fm = null) {
|
854 | return isUnique(x, fc, fm);
|
855 | }
|
856 | function iterator(x) {
|
857 | return x[Symbol.iterator]();
|
858 | }
|
859 | function join(x, sep = ",") {
|
860 | var a = "";
|
861 | for (var v of x)
|
862 | a += v + sep;
|
863 | return a.substring(0, a.length - sep.length);
|
864 | }
|
865 | function* keys(x) {
|
866 | var i = -1;
|
867 | for (var _ of x)
|
868 | yield ++i;
|
869 | }
|
870 | function last(x, vd) {
|
871 | var v = vd;
|
872 | for (var v of x)
|
873 | ;
|
874 | return v;
|
875 | }
|
876 | function searchValueRight(x, v, fc = null, fm = null) {
|
877 | var fc = fc || cmp, fm = fm || id;
|
878 | var v1 = fm(v, 0, null), i = -1, j = -1;
|
879 | for (var u of x) {
|
880 | var u1 = fm(u, ++i, x);
|
881 | if (fc(u1, v1) === 0)
|
882 | j = i;
|
883 | }
|
884 | return j;
|
885 | }
|
886 | function lastIndexOf(x, v, i = END - 1) {
|
887 | return searchValueRight(slice(x, 0, i + 1), v);
|
888 | }
|
889 | function* left(x, n = 1) {
|
890 | yield* slice(x, 0, n);
|
891 | }
|
892 | function length(x, i = 0, I = END) {
|
893 | return size(x, i, I);
|
894 | }
|
895 | function range$1(x, fc = null, fm = null) {
|
896 | return range(x, fc, fm);
|
897 | }
|
898 | function max(x, fc = null, fm = null) {
|
899 | return range$1(x, fc, fm)[1];
|
900 | }
|
901 | function min(x, fc = null, fm = null) {
|
902 | return range$1(x, fc, fm)[0];
|
903 | }
|
904 | function* merge(xs, fc = null, fm = null) {
|
905 | var X = xs.length;
|
906 | var is = [], os = [];
|
907 | for (var n = 0, i = 0; n < X; n++) {
|
908 | is[i] = xs[i][Symbol.iterator]();
|
909 | os[i] = is[i].next();
|
910 | if (!os[i].done)
|
911 | i++;
|
912 | }
|
913 | while (i > 0) {
|
914 | var vs = os.map(o => o.value);
|
915 | var j = min(vs, fc, fm)[0];
|
916 | yield vs[j];
|
917 | os[j] = is[j].next();
|
918 | if (!os[j].done)
|
919 | continue;
|
920 | is.splice(j, 1);
|
921 | os.splice(j, 1);
|
922 | i--;
|
923 | }
|
924 | }
|
925 | function* middle(x, i = 0, n = 1) {
|
926 | yield* slice(x, i, i + n);
|
927 | }
|
928 | function* movePart(x, j, k, l) {
|
929 | var p = [], i = -1;
|
930 | for (var v of x) {
|
931 | if (++i < j || i >= l)
|
932 | yield v;
|
933 | else {
|
934 | p.push(v);
|
935 | if (i < l - 1)
|
936 | continue;
|
937 | yield* p.slice(k - j);
|
938 | yield* p.slice(0, k - j);
|
939 | }
|
940 | }
|
941 | }
|
942 | function* moveWithin(x, j = 0, i = 0, I = END) {
|
943 | if (j < i)
|
944 | yield* movePart(x, j, i, I);
|
945 | else
|
946 | yield* movePart(x, i, I, j);
|
947 | }
|
948 | function partition$1(x, ft) {
|
949 | return partition(x, ft);
|
950 | }
|
951 | function partitionAs$1(x, fm = null) {
|
952 | return partitionAs(x, fm);
|
953 | }
|
954 | function* pop(x) {
|
955 | yield* init(x);
|
956 | }
|
957 | function* push(x, ...vs) {
|
958 | yield* x;
|
959 | yield* vs;
|
960 | }
|
961 | function reduce(x, fr, acc) {
|
962 | var init = arguments.length <= 2, i = -1;
|
963 | for (var v of x) {
|
964 | if (init) {
|
965 | init = false;
|
966 | acc = v;
|
967 | ++i;
|
968 | }
|
969 | else
|
970 | acc = fr(acc, v, ++i, x);
|
971 | }
|
972 | return acc;
|
973 | }
|
974 | function* reject(x, ft) {
|
975 | var i = -1;
|
976 | for (var v of x)
|
977 | if (!ft(v, ++i, x))
|
978 | yield v;
|
979 | }
|
980 | function* rejectAt(x, is) {
|
981 | var i = -1;
|
982 | for (var v of x)
|
983 | if (!is.includes(++i))
|
984 | yield v;
|
985 | }
|
986 | function* splice(x, i = 0, n = END - i, ...vs) {
|
987 | var j = -1;
|
988 | for (var u of x) {
|
989 | if (++j < i || j >= i + n)
|
990 | yield u;
|
991 | else if (j === i)
|
992 | yield* vs;
|
993 | }
|
994 | }
|
995 | function* remove(x, i) {
|
996 | yield* splice(x, i, 1);
|
997 | }
|
998 | function* reverse(x) {
|
999 | var a = from$$1(x);
|
1000 | for (var i = a.length - 1; i >= 0; i--)
|
1001 | yield a[i];
|
1002 | }
|
1003 | function* right(x, n = 1) {
|
1004 | if (n === 0)
|
1005 | return;
|
1006 | yield* slice(x, -n);
|
1007 | }
|
1008 | function* rotateLeft(x, n) {
|
1009 | var a = [], i = -1;
|
1010 | for (var v of x) {
|
1011 | if (++i < n)
|
1012 | a.push(v);
|
1013 | else
|
1014 | yield v;
|
1015 | }
|
1016 | if (++i >= n) {
|
1017 | yield* a;
|
1018 | return;
|
1019 | }
|
1020 | var n = n % i;
|
1021 | yield* a.slice(n);
|
1022 | yield* a.slice(-n);
|
1023 | }
|
1024 | function* rotateRight(x, n) {
|
1025 | var a = Array.from(x);
|
1026 | var n = n % a.length;
|
1027 | yield* a.slice(-n);
|
1028 | yield* a.slice(0, -n);
|
1029 | }
|
1030 | function* rotate(x, n = 0) {
|
1031 | if (n === 0)
|
1032 | yield* x;
|
1033 | else if (n > 0)
|
1034 | yield* rotateLeft(x, n);
|
1035 | else
|
1036 | yield* rotateRight(x, -n);
|
1037 | }
|
1038 | function scanUntil$1(x, ft) {
|
1039 | return scanUntil(x, ft);
|
1040 | }
|
1041 | function scanUntilRight(x, ft) {
|
1042 | var i = 0, a = 0;
|
1043 | for (var v of x)
|
1044 | if (ft(v, i++, x))
|
1045 | a = i;
|
1046 | return a;
|
1047 | }
|
1048 | function scanWhile$1(x, ft) {
|
1049 | return scanWhile(x, ft);
|
1050 | }
|
1051 | function scanWhileRight(x, ft) {
|
1052 | var i = 0, a = 0;
|
1053 | for (var v of x)
|
1054 | if (!ft(v, i++, x))
|
1055 | a = i;
|
1056 | return a;
|
1057 | }
|
1058 | function search(x, ft) {
|
1059 | var i = -1;
|
1060 | for (var v of x)
|
1061 | if (ft(v, ++i, x))
|
1062 | return i;
|
1063 | return -1;
|
1064 | }
|
1065 | function* searchAll(x, ft) {
|
1066 | var i = -1;
|
1067 | for (var v of x)
|
1068 | if (ft(v, ++i, x))
|
1069 | yield i;
|
1070 | }
|
1071 | function searchInfixRight(x, y, fc, fm = null) {
|
1072 | return last(searchInfixAll(x, y, fc, fm), -1);
|
1073 | }
|
1074 | function searchRight(x, ft) {
|
1075 | var i = -1, a = -1;
|
1076 | for (var v of x)
|
1077 | if (ft(v, ++i, x))
|
1078 | a = i;
|
1079 | return a;
|
1080 | }
|
1081 | function* searchValueAll(x, v, fc = null, fm = null) {
|
1082 | var fc = fc || cmp, fm = fm || id;
|
1083 | var v1 = fm(v, 0, null), i = -1;
|
1084 | for (var u of x) {
|
1085 | var u1 = fm(u, ++i, x);
|
1086 | if (fc(u1, v1) === 0)
|
1087 | yield i;
|
1088 | }
|
1089 | }
|
1090 | function* set(x, i, v) {
|
1091 | var j = -1;
|
1092 | for (var u of x)
|
1093 | yield (++j === i ? v : u);
|
1094 | if (j >= i)
|
1095 | return;
|
1096 | for (; ++j < i;)
|
1097 | yield undefined;
|
1098 | yield v;
|
1099 | }
|
1100 | function* tail(x) {
|
1101 | var i = -1;
|
1102 | for (var v of x)
|
1103 | if (++i > 0)
|
1104 | yield v;
|
1105 | }
|
1106 | function* shift(x) {
|
1107 | yield* tail(x);
|
1108 | }
|
1109 | function someBool(x) {
|
1110 | for (var v of x)
|
1111 | if (v)
|
1112 | return true;
|
1113 | return false;
|
1114 | }
|
1115 | function someTest(x, ft) {
|
1116 | var i = -1;
|
1117 | for (var v of x)
|
1118 | if (ft(v, ++i, x))
|
1119 | return true;
|
1120 | return false;
|
1121 | }
|
1122 | function some(x, ft = null) {
|
1123 | if (ft)
|
1124 | return someTest(x, ft);
|
1125 | else
|
1126 | return someBool(x);
|
1127 | }
|
1128 | function* split(x, ft) {
|
1129 | var a = [], i = -1;
|
1130 | for (var v of x) {
|
1131 | if (!ft(v, ++i, x))
|
1132 | a.push(v);
|
1133 | else if (a.length) {
|
1134 | yield a;
|
1135 | a = [];
|
1136 | }
|
1137 | }
|
1138 | if (a.length)
|
1139 | yield a;
|
1140 | }
|
1141 | function* splitAt(x, is) {
|
1142 | var a = [], i = -1;
|
1143 | for (var v of x) {
|
1144 | if (!is.includes(++i))
|
1145 | a.push(v);
|
1146 | else if (a.length) {
|
1147 | yield a;
|
1148 | a = [];
|
1149 | }
|
1150 | }
|
1151 | if (a.length)
|
1152 | yield a;
|
1153 | }
|
1154 | function* swap(x, i, j) {
|
1155 | if (i === j)
|
1156 | yield* x;
|
1157 | var k = Math.min(i, j);
|
1158 | var l = Math.max(i, j);
|
1159 | var m = [];
|
1160 | var vk, i = -1;
|
1161 | for (var v of x) {
|
1162 | if (++i < k || i > l)
|
1163 | yield v;
|
1164 | else if (i === k)
|
1165 | vk = v;
|
1166 | else if (i < l)
|
1167 | m.push(v);
|
1168 | else {
|
1169 | yield v;
|
1170 | yield* m;
|
1171 | yield vk;
|
1172 | }
|
1173 | }
|
1174 | }
|
1175 | function* symmetricDifference(x, y, fc = null, fm = null) {
|
1176 | var x = many(x), y = many(y);
|
1177 | yield* difference(x, y, fc, fm);
|
1178 | yield* difference(y, x, fc, fm);
|
1179 | }
|
1180 | function* take(x, n = 1) {
|
1181 | yield* slice(x, 0, n);
|
1182 | }
|
1183 | function* takeRight(x, n = 1) {
|
1184 | if (n > 0)
|
1185 | yield* slice(x, -n);
|
1186 | }
|
1187 | function* takeWhile(x, ft) {
|
1188 | var i = -1;
|
1189 | for (var v of x) {
|
1190 | if (ft(v, ++i, x))
|
1191 | yield v;
|
1192 | else
|
1193 | return;
|
1194 | }
|
1195 | }
|
1196 | function* takeWhileRight(x, ft) {
|
1197 | var i = -1, a = [];
|
1198 | for (var v of x) {
|
1199 | if (ft(v, ++i, x))
|
1200 | a.push(v);
|
1201 | else
|
1202 | a.length = 0;
|
1203 | }
|
1204 | yield* a;
|
1205 | }
|
1206 | function* unionMap(x, y, fm = null) {
|
1207 | var fm = fm || id;
|
1208 | var s = new Set();
|
1209 | var i = -1, j = -1;
|
1210 | for (var u of x) {
|
1211 | var u1 = fm(u, ++i, x);
|
1212 | s.add(u1);
|
1213 | yield u;
|
1214 | }
|
1215 | for (var v of y) {
|
1216 | var v1 = fm(v, ++j, y);
|
1217 | if (!s.has(v1))
|
1218 | yield v;
|
1219 | }
|
1220 | }
|
1221 | function* unionDual(x, y, fc = null, fm = null) {
|
1222 | var fc = fc || cmp, fm = fm || id;
|
1223 | var x = many(x);
|
1224 | yield* x;
|
1225 | var x1 = [...x].map(fm), j = -1;
|
1226 | y: for (var v of y) {
|
1227 | var v1 = fm(v, ++j, y);
|
1228 | for (var u1 of x1)
|
1229 | if (fc(u1, v1) === 0)
|
1230 | continue y;
|
1231 | yield v;
|
1232 | }
|
1233 | }
|
1234 | function* union(x, y, fc = null, fm = null) {
|
1235 | if (fc)
|
1236 | yield* unionDual(x, y, fc, fm);
|
1237 | else
|
1238 | yield* unionMap(x, y, fm);
|
1239 | }
|
1240 | function* uniqueMap(x, fm = null) {
|
1241 | var fm = fm || id;
|
1242 | var s = new Set(), i = -1;
|
1243 | for (var v of x) {
|
1244 | var v1 = fm(v, ++i, x);
|
1245 | if (s.has(v1))
|
1246 | continue;
|
1247 | s.add(v1);
|
1248 | yield v;
|
1249 | }
|
1250 | }
|
1251 | function* uniqueDual(x, fc = null, fm = null) {
|
1252 | var fc = fc || cmp, fm = fm || id;
|
1253 | var s = [], i = -1;
|
1254 | x: for (var v of x) {
|
1255 | var v1 = fm(v, ++i, x);
|
1256 | for (var u1 of s)
|
1257 | if (fc(u1, v1) === 0)
|
1258 | continue x;
|
1259 | s.push(v1);
|
1260 | yield v;
|
1261 | }
|
1262 | }
|
1263 | function* unique(x, fc = null, fm = null) {
|
1264 | if (fc)
|
1265 | yield* uniqueDual(x, fc, fm);
|
1266 | else
|
1267 | yield* uniqueMap(x, fm);
|
1268 | }
|
1269 | function* unshift(x, ...vs) {
|
1270 | yield* vs;
|
1271 | yield* x;
|
1272 | }
|
1273 | function* values(x) {
|
1274 | yield* x;
|
1275 | }
|
1276 | function* zip(xs, fm = null, ft = null, vd) {
|
1277 | var fm = fm || id, ft = ft || some;
|
1278 | var X = xs.length;
|
1279 | if (X === 0)
|
1280 | return;
|
1281 | var is = [], ds = [], vs = [];
|
1282 | for (var r = 0; r < X; r++)
|
1283 | is[r] = xs[r][Symbol.iterator]();
|
1284 | for (var i = 0;; i++) {
|
1285 | for (var r = 0; r < X; r++) {
|
1286 | var { done, value } = is[r].next();
|
1287 | ds[r] = done;
|
1288 | vs[r] = done ? vd : value;
|
1289 | }
|
1290 | if (ft(ds))
|
1291 | break;
|
1292 | yield fm(vs.slice(), i, null);
|
1293 | }
|
1294 | }
|
1295 | export { END, accumulate, callable, cartesianProduct, chunk, compare, concat, copy, copyWithin, count$1 as count, countAs$1 as countAs, cut, cutAt, cutAtRight, cutRight, cycle, difference, drop, dropRight, dropWhile, dropWhileRight, entries, every, fill, filter, filterAt, find, findAll, findRight, flat, flatMap, forEach, from$2 as from, fromApply, fromCall, fromRange, get, getAll, getPath, group, hasInfix, hasPath, hasPrefix, hasSubsequence, hasSuffix, hasValue, head, includes, index, indexOf, indexRange, init, interleave, intermix, interpolate, intersection, intersperse, is, isDisjoint$1 as isDisjoint, isEmpty, isEqual, isIterator, isList, isMany, isOnce, isUnique$1 as isUnique, iterator, join, keys, last, lastIndexOf, left, length, many, map, max, merge, middle, min, moveWithin, partition$1 as partition, partitionAs$1 as partitionAs, pop, push, range$1 as range, reduce, reject, rejectAt, remove, repeat, reverse, right, rotate, scanUntil$1 as scanUntil, scanUntilRight, scanWhile$1 as scanWhile, scanWhileRight, search, searchAll, searchInfix, searchInfixAll, searchInfixRight, searchRight, searchSubsequence, searchValue$1 as searchValue, searchValueAll, searchValueRight, set, shift, size, slice, some, splice, split, splitAt, swap, symmetricDifference, tail, take, takeRight, takeWhile, takeWhileRight, union, unique, unshift, values, zip };
|