1 | 'use strict';
|
2 | Object.defineProperty(exports, '__esModule', { value: true });
|
3 | function id(v) {
|
4 | return v;
|
5 | }
|
6 | function keys(x) {
|
7 | return x[0];
|
8 | }
|
9 | function values(x) {
|
10 | return x[1];
|
11 | }
|
12 | function* entries(x) {
|
13 | var vi = values(x)[Symbol.iterator]();
|
14 | for (var k of keys(x))
|
15 | yield [k, vi.next().value];
|
16 | }
|
17 | function id$1(v) {
|
18 | return v;
|
19 | }
|
20 | function* cartesianProduct(xs, fm = null) {
|
21 | var fm = fm || id$1;
|
22 | var XS = xs.length;
|
23 | var kss = xs.map(x => [...x.keys()]);
|
24 | var ls = kss.map(ks => ks.length);
|
25 | var is = kss.map(ks => 0);
|
26 | for (var j = 0;; j++) {
|
27 | var a = new Map();
|
28 | for (var n = 0; n < XS; n++) {
|
29 | var i = is[n], x = xs[n];
|
30 | var ks = kss[n], k = ks[i];
|
31 | a.set(k, x.get(k));
|
32 | }
|
33 | yield fm(a, j, null);
|
34 | for (var r = XS - 1; r >= 0; r--) {
|
35 | is[r]++;
|
36 | if (is[r] < ls[r])
|
37 | break;
|
38 | is[r] = 0;
|
39 | }
|
40 | if (r < 0)
|
41 | break;
|
42 | }
|
43 | }
|
44 | function filterAt(x, ks) {
|
45 | var a = new Map();
|
46 | for (var k of ks)
|
47 | a.set(k, x.get(k));
|
48 | return a;
|
49 | }
|
50 | function cmp(a, b) {
|
51 | return a < b ? -1 : (a > b ? 1 : 0);
|
52 | }
|
53 | function unionKeys(...xs) {
|
54 | var a = new Set();
|
55 | for (var x of xs) {
|
56 | for (var [k] of x)
|
57 | a.add(k);
|
58 | }
|
59 | return a;
|
60 | }
|
61 | function concat$(x, ...ys) {
|
62 | for (var y of ys) {
|
63 | for (var [k, v] of y)
|
64 | x.set(k, v);
|
65 | }
|
66 | return x;
|
67 | }
|
68 | function count(x, fn) {
|
69 | var a = 0;
|
70 | for (var [k, v] of x)
|
71 | if (fn(v, k, x))
|
72 | a++;
|
73 | return a;
|
74 | }
|
75 | function countAs(x, fm) {
|
76 | var fm = fm || id$1;
|
77 | var a = new Map();
|
78 | for (var [k, v] of x) {
|
79 | var v1 = fm(v, k, x);
|
80 | var n = a.get(v1) || 0;
|
81 | a.set(v1, n + 1);
|
82 | }
|
83 | return a;
|
84 | }
|
85 | function index(x, i = 0) {
|
86 | return i < 0 ? Math.max(x.length + i, 0) : Math.min(i, x.length);
|
87 | }
|
88 | function fromRange(v, V = v, s = 1) {
|
89 | var a = [];
|
90 | if (s >= 0) {
|
91 | for (; v < V; v += s)
|
92 | a.push(v);
|
93 | }
|
94 | else {
|
95 | for (; v > V; v += s)
|
96 | a.push(v);
|
97 | }
|
98 | return a;
|
99 | }
|
100 | function get(x, i) {
|
101 | return x[index(x, i)];
|
102 | }
|
103 | function getAll(x, is) {
|
104 | return is.map(i => get(x, i));
|
105 | }
|
106 | function random(r) {
|
107 | var a = Math.floor(r * 2 ** 31);
|
108 | return function () {
|
109 | var t = a += 0x6D2B79F5;
|
110 | t = Math.imul(t ^ t >>> 15, t | 1);
|
111 | t ^= t + Math.imul(t ^ t >>> 7, t | 61);
|
112 | return ((t ^ t >>> 14) >>> 0) / 4294967296;
|
113 | };
|
114 | }
|
115 | function permutation$(x, n = -1, r = Math.random()) {
|
116 | if (n > x.length)
|
117 | return x;
|
118 | var X = x.length, rnd = random(r);
|
119 | var n = n >= 0 ? n : Math.floor((X + 1) * rnd());
|
120 | for (var i = 0; i < n; i++) {
|
121 | var j = i + Math.floor((X - i) * rnd());
|
122 | var t = x[i];
|
123 | x[i] = x[j];
|
124 | x[j] = t;
|
125 | }
|
126 | x.length = n;
|
127 | return x;
|
128 | }
|
129 | function subsequenceNum(x, n, r) {
|
130 | var is = fromRange(0, x.length, 1);
|
131 | permutation$(is, n, r).sort();
|
132 | return getAll(x, is);
|
133 | }
|
134 | function subsequenceAny(x, r) {
|
135 | var rnd = random(r), a = [];
|
136 | for (var v of x)
|
137 | if (rnd() >= 0.5)
|
138 | a.push(v);
|
139 | return a;
|
140 | }
|
141 | function subsequence(x, n = -1, r = Math.random()) {
|
142 | var X = x.length;
|
143 | if (n >= 0)
|
144 | return n > X ? null : subsequenceNum(x, n, r);
|
145 | return subsequenceAny(x, r);
|
146 | }
|
147 | function* subsequences(x, n = -1) {
|
148 | var X = x.length;
|
149 | if (n >= X) {
|
150 | if (n === X)
|
151 | yield x;
|
152 | return;
|
153 | }
|
154 | if (n === 0 || X === 0) {
|
155 | yield [];
|
156 | return;
|
157 | }
|
158 | var y = x.slice(0, -1);
|
159 | yield* subsequences(y, n);
|
160 | for (var s of subsequences(y, n - 1)) {
|
161 | s.push(x[X - 1]);
|
162 | yield s;
|
163 | }
|
164 | }
|
165 | function scanWhile(x, ft) {
|
166 | for (var [k, v] of x)
|
167 | if (!ft(v, k, x))
|
168 | return k;
|
169 | }
|
170 | function every(x, ft) {
|
171 | return scanWhile(x, ft) === undefined;
|
172 | }
|
173 | function find(x, ft) {
|
174 | for (var [k, v] of x)
|
175 | if (ft(v, k, x))
|
176 | return v;
|
177 | }
|
178 | function findAll(x, ft) {
|
179 | var a = [];
|
180 | for (var [k, v] of x)
|
181 | if (ft(v, k, x))
|
182 | a.push(v);
|
183 | return a;
|
184 | }
|
185 | function forEach(x, fc) {
|
186 | for (var [k, v] of x)
|
187 | fc(v, k, x);
|
188 | }
|
189 | function fromLists(ls) {
|
190 | var [ks, vs] = ls, vi = vs[Symbol.iterator]();
|
191 | var a = new Map();
|
192 | for (var k of ks)
|
193 | a.set(k, vi.next().value);
|
194 | return a;
|
195 | }
|
196 | function getAll$1(x, ks) {
|
197 | return ks.map(k => x.get(k));
|
198 | }
|
199 | function hasSubset(x, y, fc = null, fm = null) {
|
200 | var fc = fc || cmp, fm = fm || id$1;
|
201 | for (var [k, v] of y) {
|
202 | if (!x.has(k))
|
203 | return false;
|
204 | var u1 = fm(x.get(k), k, x);
|
205 | var v1 = fm(v, k, y);
|
206 | if (fc(u1, v1) !== 0)
|
207 | return false;
|
208 | }
|
209 | return true;
|
210 | }
|
211 | function searchValue(x, v, fc = null, fm = null) {
|
212 | var fc = fc || cmp, fm = fm || id$1;
|
213 | var v1 = fm(v, null, null);
|
214 | for (var [k, u] of x) {
|
215 | var u1 = fm(u, k, x);
|
216 | if (fc(u1, v1) === 0)
|
217 | return k;
|
218 | }
|
219 | }
|
220 | function someBool(x) {
|
221 | for (var v of x)
|
222 | if (v)
|
223 | return true;
|
224 | return false;
|
225 | }
|
226 | function someTest(x, ft) {
|
227 | var i = -1;
|
228 | for (var v of x)
|
229 | if (ft(v, ++i, x))
|
230 | return true;
|
231 | return false;
|
232 | }
|
233 | function some(x, ft = null) {
|
234 | if (ft)
|
235 | return someTest(x, ft);
|
236 | else
|
237 | return someBool(x);
|
238 | }
|
239 | function intersection(x, y, fc = null) {
|
240 | var fc = fc || id$1;
|
241 | var a = new Map();
|
242 | for (var [k, v] of y)
|
243 | if (x.has(k))
|
244 | a.set(k, fc(x.get(k), v));
|
245 | return a;
|
246 | }
|
247 | function join(x, sep = ",", asc = "=") {
|
248 | var a = "";
|
249 | for (var [k, v] of x)
|
250 | a += k + asc + v + sep;
|
251 | return a.slice(0, -sep.length);
|
252 | }
|
253 | function range(x, fc = null, fm = null) {
|
254 | var fc = fc || cmp, fm = fm || id$1;
|
255 | var mk, mu, mv;
|
256 | var nk, nu, nv;
|
257 | var i = 0;
|
258 | for (var [k, u] of x) {
|
259 | var v = fm(u, k, x);
|
260 | if (i === 0 || fc(v, mv) < 0) {
|
261 | mk = k;
|
262 | mu = u;
|
263 | mv = v;
|
264 | }
|
265 | if (i === 0 || fc(v, nv) > 0) {
|
266 | nk = k;
|
267 | nu = u;
|
268 | nv = v;
|
269 | }
|
270 | i++;
|
271 | }
|
272 | return [[mk, mu], [nk, nu]];
|
273 | }
|
274 | function reduce(x, fr, acc) {
|
275 | var init = arguments.length <= 2;
|
276 | for (var [k, v] of x) {
|
277 | if (init) {
|
278 | acc = v;
|
279 | init = false;
|
280 | }
|
281 | else
|
282 | acc = fr(acc, v, k, x);
|
283 | }
|
284 | return acc;
|
285 | }
|
286 | function search(x, ft) {
|
287 | for (var [k, v] of x)
|
288 | if (ft(v, k, x))
|
289 | return k;
|
290 | }
|
291 | function scanUntil(x, ft) {
|
292 | return search(x, ft);
|
293 | }
|
294 | function searchAll(x, ft) {
|
295 | var a = [];
|
296 | for (var [k, v] of x)
|
297 | if (ft(v, k, x))
|
298 | a.push(k);
|
299 | return a;
|
300 | }
|
301 | function searchValueAll(x, v, fc = null, fm = null) {
|
302 | var fc = fc || cmp, fm = fm || id$1;
|
303 | var v1 = fm(v, null, x), a = [];
|
304 | for (var [k, u] of x) {
|
305 | var u1 = fm(u, k, x);
|
306 | if (fc(u1, v1) === 0)
|
307 | a.push(k);
|
308 | }
|
309 | return a;
|
310 | }
|
311 | function some$1(x, ft) {
|
312 | return scanUntil(x, ft) !== undefined;
|
313 | }
|
314 | function subset(x, n = -1, r = Math.random()) {
|
315 | var ks = subsequence([...x.keys()], n, r);
|
316 | return filterAt(x, ks);
|
317 | }
|
318 | function* subsets(x, n = -1) {
|
319 | for (var ks of subsequences([...x.keys()], n))
|
320 | yield filterAt(x, ks);
|
321 | }
|
322 | function symmetricDifference$(x, y) {
|
323 | for (var [k, v] of y) {
|
324 | if (x.has(k))
|
325 | x.delete(k);
|
326 | else
|
327 | x.set(k, v);
|
328 | }
|
329 | return x;
|
330 | }
|
331 | function symmetricDifference(x, y) {
|
332 | return symmetricDifference$(new Map(x), y);
|
333 | }
|
334 | function union$(x, y, fc = null) {
|
335 | var fc = fc || id$1;
|
336 | for (var [k, v] of y) {
|
337 | if (!x.has(k))
|
338 | x.set(k, v);
|
339 | else
|
340 | x.set(k, fc(x.get(k), v));
|
341 | }
|
342 | return x;
|
343 | }
|
344 | function union(x, y, fc = null) {
|
345 | return union$(new Map(x), y, fc);
|
346 | }
|
347 | function zip(xs, fm = null, ft = null, vd) {
|
348 | var fm = fm || id$1, ft = ft || some;
|
349 | var ks = unionKeys(...xs), a = new Map();
|
350 | for (var k of ks) {
|
351 | var ds = xs.map(x => !x.has(k));
|
352 | if (ft(ds))
|
353 | break;
|
354 | var vs = xs.map(x => !x.has(k) ? vd : x.get(k));
|
355 | a.set(k, fm(vs, k, null));
|
356 | }
|
357 | return a;
|
358 | }
|
359 | function* cartesianProduct$1(xs, fm = null) {
|
360 | var fm = fm || id, ys = xs.map(x => new Map(entries(x)));
|
361 | yield* cartesianProduct(ys, (vs, i) => fm([vs.keys(), vs.values()], i, null));
|
362 | }
|
363 | function id$2(v) {
|
364 | return v;
|
365 | }
|
366 | function chunk(x, n = 1, s = n) {
|
367 | var a = [];
|
368 | for (var i = 0, I = x.length; i < I; i += s)
|
369 | a.push(x.slice(i, i + n));
|
370 | return a;
|
371 | }
|
372 | function someBool$1(x) {
|
373 | for (var i = 0, I = x.length; i < I; i++)
|
374 | if (x[i])
|
375 | return true;
|
376 | return false;
|
377 | }
|
378 | function some$2(x, ft = null) {
|
379 | if (ft)
|
380 | return x.some(ft);
|
381 | else
|
382 | return someBool$1(x);
|
383 | }
|
384 | function value(x, r = Math.random()) {
|
385 | var i = Math.floor(r * x.length);
|
386 | return x[i];
|
387 | }
|
388 | function zip$1(xs, fm = null, ft = null, vd) {
|
389 | var fm = fm || id$2, ft = ft || some$2;
|
390 | var X = xs.length, a = [];
|
391 | if (X === 0)
|
392 | return a;
|
393 | var ds = new Array(X).fill(false);
|
394 | var ls = xs.map(x => x.length);
|
395 | for (var i = 0;; i++) {
|
396 | for (var j = 0, vs = []; j < X; j++) {
|
397 | ds[j] = i >= ls[j];
|
398 | vs[j] = ds[j] ? vd : xs[j][i];
|
399 | }
|
400 | if (ft(ds))
|
401 | break;
|
402 | a.push(fm(vs, i, null));
|
403 | }
|
404 | return a;
|
405 | }
|
406 | function chunk$1(x, n = 1, s = n) {
|
407 | var kss = chunk([...keys(x)], n, s);
|
408 | var vss = chunk([...values(x)], n, s);
|
409 | return zip$1([kss, vss]);
|
410 | }
|
411 | function id$3(v) {
|
412 | return v;
|
413 | }
|
414 | function cmp$1(a, b) {
|
415 | return a < b ? -1 : (a > b ? 1 : 0);
|
416 | }
|
417 | function unionKeys$1(...xs) {
|
418 | var a = new Set();
|
419 | for (var x of xs) {
|
420 | for (var [k] of x)
|
421 | a.add(k);
|
422 | }
|
423 | return a;
|
424 | }
|
425 | function compare(x, y, fc = null, fm = null) {
|
426 | var fc = fc || cmp$1, fm = fm || id$3;
|
427 | var ks = unionKeys$1(x, y);
|
428 | for (var k of ks) {
|
429 | if (!x.has(k))
|
430 | return -1;
|
431 | if (!y.has(k))
|
432 | return 1;
|
433 | var u = fm(x.get(k), k, x);
|
434 | var v = fm(y.get(k), k, y);
|
435 | var c = fc(u, v);
|
436 | if (c !== 0)
|
437 | return c;
|
438 | }
|
439 | return 0;
|
440 | }
|
441 | function compare$1(x, y, fc = null, fm = null) {
|
442 | return compare(new Map(x), new Map(y), fc, fm);
|
443 | }
|
444 | function get$1(x, k) {
|
445 | for (var [j, u] of x)
|
446 | if (k === j)
|
447 | return u;
|
448 | }
|
449 | function compare$2(x, y, fc, fm) {
|
450 | return compare$1(entries(x), entries(y), fc, fm);
|
451 | }
|
452 | function is(v) {
|
453 | return v != null && typeof v[Symbol.iterator] === "function";
|
454 | }
|
455 | function* concat(...xs) {
|
456 | for (var x of xs)
|
457 | yield* x;
|
458 | }
|
459 | const END = Number.MAX_SAFE_INTEGER;
|
460 | function* slicePos(x, i, I) {
|
461 | var k = -1;
|
462 | for (var v of x) {
|
463 | if (++k >= I)
|
464 | break;
|
465 | if (k >= i)
|
466 | yield v;
|
467 | }
|
468 | }
|
469 | function* slicePosNeg(x, i, I) {
|
470 | var j = 0, k = -1;
|
471 | var a = [], A = -I;
|
472 | for (var v of x) {
|
473 | if (++k < i)
|
474 | continue;
|
475 | if (a.length >= A)
|
476 | yield a[j];
|
477 | a[j] = v;
|
478 | j = (j + 1) % A;
|
479 | }
|
480 | }
|
481 | function* sliceNeg(x, i, I) {
|
482 | var j = 0, n = 0;
|
483 | var a = [], A = -i;
|
484 | for (var v of x) {
|
485 | a[j] = v;
|
486 | j = (j + 1) % A;
|
487 | n++;
|
488 | }
|
489 | if (n < A)
|
490 | return;
|
491 | var I = I < 0 ? I : Math.min(I - n, 0);
|
492 | var n = Math.max(I - i, 0);
|
493 | var J = Math.max(j + n - A, 0);
|
494 | yield* a.slice(j, j + n);
|
495 | yield* a.slice(0, J);
|
496 | }
|
497 | function* slice(x, i = 0, I = END) {
|
498 | if (i >= 0 && I >= 0)
|
499 | yield* slicePos(x, i, I);
|
500 | else if (i >= 0 && I < 0)
|
501 | yield* slicePosNeg(x, i, I);
|
502 | else
|
503 | yield* sliceNeg(x, i, I);
|
504 | }
|
505 | function size(x, i = 0, I = END) {
|
506 | var j = -1, n = 0;
|
507 | for (var _ of x)
|
508 | if (++j >= i && j < I)
|
509 | n++;
|
510 | return n;
|
511 | }
|
512 | function id$1$1(v) {
|
513 | return v;
|
514 | }
|
515 | function cmp$1$1(a, b) {
|
516 | return a < b ? -1 : (a > b ? 1 : 0);
|
517 | }
|
518 | function searchValue$1(x, v, fc = null, fm = null) {
|
519 | var fc = fc || cmp$1$1, fm = fm || id$1$1;
|
520 | var v1 = fm(v, 0, null), i = -1;
|
521 | for (var u of x) {
|
522 | var u1 = fm(u, ++i, x);
|
523 | if (fc(u1, v1) === 0)
|
524 | return i;
|
525 | }
|
526 | return -1;
|
527 | }
|
528 | function* map(x, fm) {
|
529 | var i = -1;
|
530 | for (var v of x)
|
531 | yield fm(v, ++i, x);
|
532 | }
|
533 | function* drop(x, n = 1) {
|
534 | yield* slice(x, n);
|
535 | }
|
536 | function isList(v) {
|
537 | return is(v) && typeof v !== "string";
|
538 | }
|
539 | function head(x, vd) {
|
540 | for (var v of x)
|
541 | return v;
|
542 | return vd;
|
543 | }
|
544 | function searchValue$1$1(x, v, fc = null, fm = null) {
|
545 | return searchValue$1(x, v, fc, fm);
|
546 | }
|
547 | function hasValue(x, v, fc = null, fm = null) {
|
548 | return searchValue$1$1(x, v, fc, fm) >= 0;
|
549 | }
|
550 | function isEmpty(x) {
|
551 | for (var _ of x)
|
552 | return false;
|
553 | return true;
|
554 | }
|
555 | function* take(x, n = 1) {
|
556 | yield* slice(x, 0, n);
|
557 | }
|
558 | function concat$1(...xs) {
|
559 | var ks = concat(...xs.map(keys));
|
560 | var vs = concat(...xs.map(values));
|
561 | return [ks, vs];
|
562 | }
|
563 | function count$1(x, ft) {
|
564 | return count(entries(x), ft);
|
565 | }
|
566 | function countAs$1(x, fm = null) {
|
567 | return countAs(entries(x), fm);
|
568 | }
|
569 | function difference(x, y) {
|
570 | var a = fromLists(x);
|
571 | for (var k of keys(y))
|
572 | a.delete(k);
|
573 | return [a.keys(), a.values()];
|
574 | }
|
575 | function drop$1(x, n = 1) {
|
576 | var ks = drop(keys(x), n);
|
577 | var vs = drop(values(x), n);
|
578 | return [ks, vs];
|
579 | }
|
580 | function entry(x, r = Math.random()) {
|
581 | return value([...entries(x)], r);
|
582 | }
|
583 | function every$1(x, ft) {
|
584 | return every(entries(x), ft);
|
585 | }
|
586 | function filter(x, ft) {
|
587 | var ks = [], vs = [];
|
588 | for (var [k, v] of entries(x))
|
589 | if (ft(v, k, x)) {
|
590 | ks.push(k);
|
591 | vs.push(v);
|
592 | }
|
593 | return [ks, vs];
|
594 | }
|
595 | function filterAt$1(x, ks) {
|
596 | var js = [], us = [];
|
597 | for (var [k, v] of entries(x))
|
598 | if (ks.includes(k)) {
|
599 | js.push(k);
|
600 | us.push(v);
|
601 | }
|
602 | return [js, us];
|
603 | }
|
604 | function find$1(x, ft) {
|
605 | return find(entries(x), ft);
|
606 | }
|
607 | function findAll$1(x, ft) {
|
608 | return findAll(entries(x), ft);
|
609 | }
|
610 | function is$1(v) {
|
611 | return Array.isArray(v) && v.length === 2 && isList(v[0]) && isList(v[1]);
|
612 | }
|
613 | function flatTo(x, n, fm, ft, a) {
|
614 | for (var [k, v] of entries(x)) {
|
615 | var v1 = fm(v, k, x);
|
616 | if (n !== 0 && ft(v1, k, x))
|
617 | flatTo(v1, n - 1, fm, ft, a);
|
618 | else
|
619 | a.set(k, v1);
|
620 | }
|
621 | return a;
|
622 | }
|
623 | function flat(x, n = -1, fm = null, ft = null) {
|
624 | var fm = fm || id, ft = ft || is$1;
|
625 | var a = flatTo(x, n, fm, ft, new Map());
|
626 | return [a.keys(), a.values()];
|
627 | }
|
628 | function flatMap(x, fm = null, ft = null) {
|
629 | var fm = fm || id, ft = ft || is$1;
|
630 | var a = new Map();
|
631 | for (var [k, v] of entries(x)) {
|
632 | var v1 = fm(v, k, x);
|
633 | if (ft(v1, k, x))
|
634 | concat$(a, entries(v1));
|
635 | else
|
636 | a.set(k, v1);
|
637 | }
|
638 | return [a.keys(), a.values()];
|
639 | }
|
640 | function forEach$1(x, fc) {
|
641 | forEach(entries(x), fc);
|
642 | }
|
643 | function fromEntries(es) {
|
644 | var a = new Map(es);
|
645 | return [a.keys(), a.values()];
|
646 | }
|
647 | function get$2(x, k) {
|
648 | return get$1(entries(x), k);
|
649 | }
|
650 | function getAll$2(x, ks) {
|
651 | return getAll$1(new Map(entries(x)), ks);
|
652 | }
|
653 | function getPath(x, p) {
|
654 | for (var k of p)
|
655 | x = is$1(x) ? get$2(x, k) : undefined;
|
656 | return x;
|
657 | }
|
658 | function has(x, k) {
|
659 | return hasValue(keys(x), k);
|
660 | }
|
661 | function cmp$2(a, b) {
|
662 | return a < b ? -1 : (a > b ? 1 : 0);
|
663 | }
|
664 | function hasEntry(x, e, fc = null, fm = null) {
|
665 | var fc = fc || cmp$2, fm = fm || id, [k, v] = e;
|
666 | var [k, v] = e, u = get$2(x, k);
|
667 | return fc(fm(u, k, x), v) === 0;
|
668 | }
|
669 | function hasPath(x, p) {
|
670 | return getPath(x, p) !== undefined;
|
671 | }
|
672 | function hasSubset$1(x, y, fc = null, fm = null) {
|
673 | return hasSubset(new Map(entries(x)), entries(y), fc, fm);
|
674 | }
|
675 | function searchValue$2(x, v, fc = null, fm = null) {
|
676 | return searchValue(entries(x), v, fc, fm);
|
677 | }
|
678 | function hasValue$1(x, v, fc = null, fm = null) {
|
679 | return searchValue$2(x, v, fc, fm) !== undefined;
|
680 | }
|
681 | function head$1(x, ed = []) {
|
682 | return head(entries(x), ed);
|
683 | }
|
684 | function intersection$1(x, y, fc = null) {
|
685 | var a = intersection(new Map(entries(x)), entries(y), fc);
|
686 | return [a.keys(), a.values()];
|
687 | }
|
688 | function concat$$1(x, ...ys) {
|
689 | for (var y of ys) {
|
690 | for (var v of y)
|
691 | x.add(v);
|
692 | }
|
693 | return x;
|
694 | }
|
695 | function concat$2(...xs) {
|
696 | return concat$$1(new Set(), ...xs);
|
697 | }
|
698 | function isDisjoint(x, y) {
|
699 | for (var v of y)
|
700 | if (x.has(v))
|
701 | return false;
|
702 | return true;
|
703 | }
|
704 | function isDisjoint$1(x, y) {
|
705 | return isDisjoint(new Set(keys(x)), keys(y));
|
706 | }
|
707 | function isEmpty$1(x) {
|
708 | return isEmpty(keys(x));
|
709 | }
|
710 | function isEqual(x, y, fc = null, fm = null) {
|
711 | return compare$2(x, y, fc, fm) === 0;
|
712 | }
|
713 | function join$1(x, sep = ',', asc = '=') {
|
714 | return join(entries(x), sep, asc);
|
715 | }
|
716 | function key(x, r = Math.random()) {
|
717 | return value([...keys(x)], r);
|
718 | }
|
719 | function size$1(x) {
|
720 | return size(keys(x));
|
721 | }
|
722 | function length(x) {
|
723 | return size$1(x);
|
724 | }
|
725 | function map$1(x, fm) {
|
726 | var ks = [], vs = [];
|
727 | for (var [k, v] of entries(x)) {
|
728 | ks.push(k);
|
729 | vs.push(fm(v, k, x));
|
730 | }
|
731 | return [ks, vs];
|
732 | }
|
733 | function range$1(x, fc = null, fm = null) {
|
734 | return range(entries(x), fc, fm);
|
735 | }
|
736 | function max(x, fc = null, fm = null) {
|
737 | return range$1(x, fc, fm)[1];
|
738 | }
|
739 | function min(x, fc = null, fm = null) {
|
740 | return range$1(x, fc, fm)[0];
|
741 | }
|
742 | function partition(x, ft) {
|
743 | var tk = [], tv = [], fk = [], fv = [];
|
744 | for (var [k, v] of entries(x)) {
|
745 | if (ft(v, k, x)) {
|
746 | tk.push(k);
|
747 | tv.push(v);
|
748 | }
|
749 | else {
|
750 | fk.push(k);
|
751 | fv.push(v);
|
752 | }
|
753 | }
|
754 | return [[tk, tv], [fk, fv]];
|
755 | }
|
756 | function partitionAs(x, fm = null) {
|
757 | var fm = fm || id, a = new Map();
|
758 | for (var [k, v] of entries(x)) {
|
759 | var v1 = fm(v, k, x);
|
760 | if (!a.has(v1))
|
761 | a.set(v1, [[], []]);
|
762 | var [ak, av] = a.get(v1);
|
763 | ak.push(k);
|
764 | av.push(v);
|
765 | }
|
766 | return a;
|
767 | }
|
768 | function reduce$1(x, fr, acc) {
|
769 | var A = arguments.length, es = entries(x);
|
770 | return A > 2 ? reduce(es, fr, acc) : reduce(es, fr);
|
771 | }
|
772 | function reject(x, ft) {
|
773 | var ks = [], vs = [];
|
774 | for (var [k, v] of entries(x))
|
775 | if (!ft(v, k, x)) {
|
776 | ks.push(k);
|
777 | vs.push(v);
|
778 | }
|
779 | return [ks, vs];
|
780 | }
|
781 | function rejectAt(x, ks) {
|
782 | var js = [], us = [];
|
783 | for (var [k, v] of entries(x))
|
784 | if (!ks.includes(k)) {
|
785 | js.push(k);
|
786 | us.push(v);
|
787 | }
|
788 | return [js, us];
|
789 | }
|
790 | function remove(x, k) {
|
791 | var ks = [], vs = [];
|
792 | for (var [j, u] of entries(x))
|
793 | if (j !== k) {
|
794 | ks.push(j);
|
795 | vs.push(u);
|
796 | }
|
797 | return [ks, vs];
|
798 | }
|
799 | function scanUntil$1(x, ft) {
|
800 | return scanUntil(entries(x), ft);
|
801 | }
|
802 | function scanWhile$1(x, ft) {
|
803 | return scanWhile(entries(x), ft);
|
804 | }
|
805 | function search$1(x, ft) {
|
806 | return search(entries(x), ft);
|
807 | }
|
808 | function searchAll$1(x, ft) {
|
809 | return searchAll(entries(x), ft);
|
810 | }
|
811 | function searchValueAll$1(x, v, fc = null, fm = null) {
|
812 | return searchValueAll(entries(x), v, fc, fm);
|
813 | }
|
814 | function set(x, k, v) {
|
815 | var ks = [], vs = [];
|
816 | for (var [j, u] of entries(x)) {
|
817 | ks.push(j);
|
818 | vs.push(j === k ? v : u);
|
819 | }
|
820 | return [ks, vs];
|
821 | }
|
822 | function shift(x) {
|
823 | return drop$1(x, 1);
|
824 | }
|
825 | function some$3(x, ft = null) {
|
826 | return some$1(entries(x), ft);
|
827 | }
|
828 | function subset$1(x, n = -1, r = Math.random()) {
|
829 | var a = subset(new Map(entries(x)), n, r);
|
830 | return [a.keys(), a.values()];
|
831 | }
|
832 | function* subsets$1(x, n = -1) {
|
833 | for (var a of subsets(new Map(entries(x)), n))
|
834 | yield [a.keys(), a.values()];
|
835 | }
|
836 | function swap(x, k, l) {
|
837 | var ks = map(keys(x), j => j === k ? l : (j === l ? k : j));
|
838 | return [ks, values(x)];
|
839 | }
|
840 | function symmetricDifference$1(x, y) {
|
841 | var a = symmetricDifference(entries(x), entries(y));
|
842 | return [a.keys(), a.values()];
|
843 | }
|
844 | function tail(x) {
|
845 | return drop$1(x, 1);
|
846 | }
|
847 | function take$1(x, n = 1) {
|
848 | var ks = take(keys(x), n);
|
849 | var vs = take(values(x), n);
|
850 | return [ks, vs];
|
851 | }
|
852 | function union$1(x, y, fc = null) {
|
853 | var a = union(entries(x), entries(y), fc);
|
854 | return [a.keys(), a.values()];
|
855 | }
|
856 | function unionKeys$2(...xs) {
|
857 | return concat$2(...xs.map(x => keys(x)));
|
858 | }
|
859 | function value$1(x, r = Math.random()) {
|
860 | return value([...values(x)], r);
|
861 | }
|
862 | function zip$2(xs, fm = null, ft = null, vd) {
|
863 | var a = zip(xs.map(x => new Map(entries(x))), fm, ft, vd);
|
864 | return [a.keys(), a.values()];
|
865 | }
|
866 | exports.cartesianProduct = cartesianProduct$1;
|
867 | exports.chunk = chunk$1;
|
868 | exports.compare = compare$2;
|
869 | exports.concat = concat$1;
|
870 | exports.count = count$1;
|
871 | exports.countAs = countAs$1;
|
872 | exports.difference = difference;
|
873 | exports.drop = drop$1;
|
874 | exports.entries = entries;
|
875 | exports.entry = entry;
|
876 | exports.every = every$1;
|
877 | exports.filter = filter;
|
878 | exports.filterAt = filterAt$1;
|
879 | exports.find = find$1;
|
880 | exports.findAll = findAll$1;
|
881 | exports.flat = flat;
|
882 | exports.flatMap = flatMap;
|
883 | exports.forEach = forEach$1;
|
884 | exports.fromEntries = fromEntries;
|
885 | exports.get = get$2;
|
886 | exports.getAll = getAll$2;
|
887 | exports.getPath = getPath;
|
888 | exports.has = has;
|
889 | exports.hasEntry = hasEntry;
|
890 | exports.hasPath = hasPath;
|
891 | exports.hasSubset = hasSubset$1;
|
892 | exports.hasValue = hasValue$1;
|
893 | exports.head = head$1;
|
894 | exports.intersection = intersection$1;
|
895 | exports.is = is$1;
|
896 | exports.isDisjoint = isDisjoint$1;
|
897 | exports.isEmpty = isEmpty$1;
|
898 | exports.isEqual = isEqual;
|
899 | exports.join = join$1;
|
900 | exports.key = key;
|
901 | exports.keys = keys;
|
902 | exports.length = length;
|
903 | exports.map = map$1;
|
904 | exports.max = max;
|
905 | exports.min = min;
|
906 | exports.partition = partition;
|
907 | exports.partitionAs = partitionAs;
|
908 | exports.range = range$1;
|
909 | exports.reduce = reduce$1;
|
910 | exports.reject = reject;
|
911 | exports.rejectAt = rejectAt;
|
912 | exports.remove = remove;
|
913 | exports.scanUntil = scanUntil$1;
|
914 | exports.scanWhile = scanWhile$1;
|
915 | exports.search = search$1;
|
916 | exports.searchAll = searchAll$1;
|
917 | exports.searchValue = searchValue$2;
|
918 | exports.searchValueAll = searchValueAll$1;
|
919 | exports.set = set;
|
920 | exports.shift = shift;
|
921 | exports.size = size$1;
|
922 | exports.some = some$3;
|
923 | exports.subset = subset$1;
|
924 | exports.subsets = subsets$1;
|
925 | exports.swap = swap;
|
926 | exports.symmetricDifference = symmetricDifference$1;
|
927 | exports.tail = tail;
|
928 | exports.take = take$1;
|
929 | exports.union = union$1;
|
930 | exports.unionKeys = unionKeys$2;
|
931 | exports.value = value$1;
|
932 | exports.values = values;
|
933 | exports.zip = zip$2;
|