extra-lists/index.js

A collection of functions for operating upon Lists.

'use strict';

function IDENTITY$3(v) {
    return v;
}
function COMPARE$3(a, b) {
    return a < b ? -1 : (a > b ? 1 : 0);
}

function IDENTITY$2(v) {
    return v;
}
function COMPARE$2(a, b) {
    return a < b ? -1 : (a > b ? 1 : 0);
}
const END = Number.MAX_SAFE_INTEGER;
function is$1(v) {
    return v != null && typeof v[Symbol.iterator] === "function";
}
function isList(v) {
    return is$1(v) && typeof v !== "string";
}
function isOnce(x) {
    return x[Symbol.iterator]() === x;
}
function toMany(x, now = false) {
    if (!isOnce(x))
        return x;
    return now ? Array.from(x) : toManyLate(x[Symbol.iterator](), []);
}
function toManyLate(ix, a) {
    return {
        [Symbol.iterator]: () => {
            var i = -1;
            return {
                next: () => {
                    if (++i < a.length)
                        return { value: a[i], done: false };
                    var { value, done } = ix.next();
                    if (!done)
                        a[i] = value;
                    return { value, done };
                }
            };
        }
    };
}
function isEmpty$1(x) {
    for (var _ of x)
        return false;
    return true;
}
function length(x, i = 0, I = END) {
    var j = -1, n = 0;
    for (var _ of x)
        if (++j >= i && j < I)
            ++n;
    return n;
}
function slice(x, i = 0, I = END) {
    if (i >= 0 && I >= 0)
        return slicePos(x, i, I);
    else if (i >= 0 && I < 0)
        return slicePosNeg(x, i, I);
    else
        return sliceNeg(x, i, I);
}
function* slicePos(x, i, I) {
    var k = -1;
    for (var v of x) {
        if (++k >= I)
            break;
        if (k >= i)
            yield v;
    }
}
function* slicePosNeg(x, i, I) {
    var j = 0, k = -1;
    var a = [], A = -I;
    for (var v of x) {
        if (++k < i)
            continue;
        if (a.length >= A)
            yield a[j];
        a[j] = v;
        j = (j + 1) % A;
    }
}
function* sliceNeg(x, i, I) {
    var j = 0, X = 0;
    var a = [], A = -i;
    for (var v of x) {
        a[j] = v;
        j = (j + 1) % A;
        ++X;
    }
    var i = Math.max(X + i, 0);
    var I = I < 0 ? Math.max(X + I, 0) : Math.min(I, X);
    var n = Math.max(I - i, 0);
    var J = Math.max(j + n - A, 0);
    yield* a.slice(j, j + n);
    yield* a.slice(0, J);
}
function head$1(x, vd) {
    for (var v of x)
        return v;
    return vd;
}
function take$1(x, n = 1) {
    return slice(x, 0, n);
}
function drop$1(x, n = 1) {
    return slice(x, n);
}
function searchValue$2(x, v, fc = null, fm = null) {
    var fc = fc || COMPARE$2;
    var fm = fm || IDENTITY$2;
    var v1 = fm(v, 0, null), i = -1;
    for (var u of x) {
        var u1 = fm(u, ++i, x);
        if (fc(u1, v1) === 0)
            return i;
    }
    return -1;
}
function hasValue$1(x, v, fc = null, fm = null) {
    return searchValue$2(x, v, fc, fm) >= 0;
}
function* map$1(x, fm) {
    var i = -1;
    for (var v of x)
        yield fm(v, ++i, x);
}
function* concat$2(...xs) {
    for (var x of xs)
        yield* x;
}

function IDENTITY$1$1(v) {
    return v;
}
function randomValue$1(x, fr = Math.random) {
    var i = Math.floor(fr() * x.length);
    return x[i];
}
function some$3(x, ft = null) {
    if (ft)
        return x.some(ft);
    else
        return someBoolean$1(x);
}
function someBoolean$1(x) {
    for (var i = 0, I = x.length; i < I; ++i)
        if (x[i])
            return true;
    return false;
}
function zip$2(xs, fm = null, fe = null, vd) {
    var fm = fm || IDENTITY$1$1;
    var fe = fe || some$3;
    var X = xs.length, a = [];
    if (X === 0)
        return a;
    var ds = new Array(X).fill(false);
    var ls = xs.map(x => x.length);
    for (var i = 0;; ++i) {
        for (var j = 0, vs = []; j < X; ++j) {
            ds[j] = i >= ls[j];
            vs[j] = ds[j] ? vd : xs[j][i];
        }
        if (fe(ds))
            break;
        a.push(fm(vs, i, null));
    }
    return a;
}
function chunk$1(x, n = 1, s = n) {
    var a = [];
    for (var i = 0, I = x.length; i < I; i += s)
        a.push(x.slice(i, i + n));
    return a;
}

function concat$1(...xs) {
    return concat$$1(new Set(), ...xs);
}
function concat$$1(x, ...ys) {
    for (var y of ys) {
        for (var v of y)
            x.add(v);
    }
    return x;
}
function isDisjoint$1(x, y) {
    for (var v of y)
        if (x.has(v))
            return false;
    return true;
}

function IDENTITY$1(v) {
    return v;
}
function COMPARE$1(a, b) {
    return a < b ? -1 : (a > b ? 1 : 0);
}
function* keys$1(x) {
    for (var [k] of x)
        yield k;
}
function* values$1(x) {
    for (var [, v] of x)
        yield v;
}
function get$2(x, k) {
    for (var [j, u] of x)
        if (j === k)
            return u;
}
function count$1(x, ft) {
    var a = 0;
    for (var [k, v] of x)
        if (ft(v, k, x))
            ++a;
    return a;
}
function countAs$1(x, fm = null) {
    var fm = fm || IDENTITY$1;
    var a = new Map();
    for (var [k, v] of x) {
        var w = fm(v, k, x);
        var n = a.get(w) || 0;
        a.set(w, n + 1);
    }
    return a;
}
function rangeEntries$1(x, fc = null, fm = null) {
    var fc = fc || COMPARE$1;
    var fm = fm || IDENTITY$1;
    var mk, mu, mv;
    var nk, nu, nv;
    var i = 0;
    for (var [k, u] of x) {
        var v = fm(u, k, x);
        if (i === 0 || fc(v, mv) < 0) {
            mk = k;
            mu = u;
            mv = v;
        }
        if (i === 0 || fc(v, nv) > 0) {
            nk = k;
            nu = u;
            nv = v;
        }
        ++i;
    }
    return [[mk, mu], [nk, nu]];
}
function find$1(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            return v;
}
function* findAll$1(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            yield v;
}
function search$1(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            return k;
}
function* searchAll$1(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            yield k;
}
function searchValue$1(x, v, fc = null, fm = null) {
    var fc = fc || COMPARE$1;
    var fm = fm || IDENTITY$1;
    var w = fm(v, null, null);
    for (var [k, u] of x) {
        var wx = fm(u, k, x);
        if (fc(wx, w) === 0)
            return k;
    }
}
function* searchValueAll$1(x, v, fc = null, fm = null) {
    var fc = fc || COMPARE$1;
    var fm = fm || IDENTITY$1;
    var w = fm(v, null, null);
    for (var [k, u] of x) {
        var wx = fm(u, k, x);
        if (fc(wx, w) === 0)
            yield k;
    }
}
function forEach$1(x, fp) {
    for (var [k, v] of x)
        fp(v, k, x);
}
function some$2(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            return true;
    return false;
}
function every$1(x, ft) {
    for (var [k, v] of x)
        if (!ft(v, k, x))
            return false;
    return true;
}
function reduce$1(x, fr, acc) {
    var init = arguments.length <= 2;
    for (var [k, v] of x) {
        if (init) {
            init = false;
            acc = v;
        }
        else
            acc = fr(acc, v, k, x);
    }
    return acc;
}
function join$1(x, sep = ",", asc = "=") {
    var a = "";
    for (var [k, v] of x)
        a += k + asc + v + sep;
    return a.slice(0, -sep.length);
}

function IDENTITY(v) {
    return v;
}
function COMPARE(a, b) {
    return a < b ? -1 : (a > b ? 1 : 0);
}
function fromRange(v, V, dv = 1) {
    var n = (V - v) / dv, a = [];
    for (var i = 0; i < n; ++i, v += dv)
        a.push(v);
    return a;
}
function index(x, i) {
    var X = x.length;
    return i >= 0 ? Math.min(i, X) : Math.max(X + i, 0);
}
function get$1(x, i) {
    return x[index(x, i)];
}
function getAll$1(x, is) {
    return is.map(i => get$1(x, i));
}
function* subsequences(x, n = -1) {
    var X = x.length;
    if (n > X)
        return;
    if (n === X) {
        yield x;
        return;
    }
    if (n === 0 || X === 0) {
        yield [];
        return;
    }
    var y = x.slice(0, -1);
    yield* subsequences(y, n);
    for (var s of subsequences(y, n - 1)) {
        s.push(x[X - 1]);
        yield s;
    }
}
function randomSubsequence(x, n = -1, fr = Math.random) {
    var X = x.length;
    if (n > X)
        return null;
    if (n >= 0)
        return randomSubsequenceFixed(x, n, fr);
    else
        return randomSubsequenceAll(x, fr);
}
function randomSubsequenceFixed(x, n, fr) {
    var is = fromRange(0, x.length);
    randomPermutation$(is, n, fr).sort();
    return getAll$1(x, is);
}
function randomSubsequenceAll(x, fr) {
    var a = [];
    for (var v of x)
        if (fr() < 0.5)
            a.push(v);
    return a;
}
function randomPermutation$(x, n = -1, fr = Math.random) {
    var X = x.length;
    if (n > X)
        return x;
    var n = n >= 0 ? n : Math.floor((X + 1) * fr());
    for (var i = 0; i < n; ++i) {
        var j = i + Math.floor((X - i) * fr());
        var t = x[i];
        x[i] = x[j];
        x[j] = t;
    }
    x.length = n;
    return x;
}
function some$1(x, ft = null) {
    if (ft)
        return x.some(ft);
    else
        return someBoolean(x);
}
function someBoolean(x) {
    for (var i = 0, I = x.length; i < I; ++i)
        if (x[i])
            return true;
    return false;
}
function fromLists(x) {
    var [ks, vs] = x;
    var iv = vs[Symbol.iterator]();
    var a = new Map();
    for (var k of ks)
        a.set(k, iv.next().value);
    return a;
}
function compare$1(x, y, fc = null, fm = null) {
    var fc = fc || COMPARE;
    var fm = fm || IDENTITY;
    var ks = unionKeys$1(x, y);
    for (var k of ks) {
        if (!x.has(k))
            return -1;
        if (!y.has(k))
            return 1;
        var vx = fm(x.get(k), k, x);
        var vy = fm(y.get(k), k, y);
        var c = fc(vx, vy);
        if (c !== 0)
            return c;
    }
    return 0;
}
function getAll$2(x, ks) {
    return ks.map(k => x.get(k));
}
function* subsets$1(x, n = -1) {
    for (var ks of subsequences([...x.keys()], n))
        yield filterAt$1(x, ks);
}
function randomSubset$1(x, n = -1, fr = Math.random) {
    var ks = randomSubsequence([...x.keys()], n, fr);
    return filterAt$1(x, ks);
}
function hasSubset$1(x, y, fc = null, fm = null) {
    var fc = fc || COMPARE;
    var fm = fm || IDENTITY;
    for (var [k, v] of y) {
        if (!x.has(k))
            return false;
        var wx = fm(x.get(k), k, x);
        var wy = fm(v, k, y);
        if (fc(wx, wy) !== 0)
            return false;
    }
    return true;
}
function filterAt$1(x, ks) {
    var a = new Map();
    for (var k of ks)
        a.set(k, x.get(k));
    return a;
}
function zip$1(xs, fm = null, fe = null, vd) {
    var fm = fm || IDENTITY;
    var fe = fe || some$1;
    var ks = unionKeys$1(...xs), a = new Map();
    for (var k of ks) {
        var ds = xs.map(x => !x.has(k));
        if (fe(ds))
            break;
        var vs = xs.map(x => !x.has(k) ? vd : x.get(k));
        a.set(k, fm(vs, k, null));
    }
    return a;
}
function concat$(x, ...ys) {
    for (var y of ys) {
        for (var [k, v] of y)
            x.set(k, v);
    }
    return x;
}
function unionKeys$1(...xs) {
    var a = new Set();
    for (var x of xs) {
        for (var [k] of x)
            a.add(k);
    }
    return a;
}
function union$1(x, y, fc = null) {
    return union$(new Map(x), y, fc);
}
function union$(x, y, fc = null) {
    var fc = fc || IDENTITY;
    for (var [k, v] of y) {
        if (!x.has(k))
            x.set(k, v);
        else
            x.set(k, fc(x.get(k), v));
    }
    return x;
}
function intersection$1(x, y, fc = null) {
    var fc = fc || IDENTITY;
    var a = new Map();
    for (var [k, v] of y)
        if (x.has(k))
            a.set(k, fc(x.get(k), v));
    return a;
}
function symmetricDifference$1(x, y) {
    return symmetricDifference$(new Map(x), y);
}
function symmetricDifference$(x, y) {
    for (var [k, v] of y) {
        if (x.has(k))
            x.delete(k);
        else
            x.set(k, v);
    }
    return x;
}

function is(v) {
    return Array.isArray(v) && v.length === 2 && isList(v[0]) && isList(v[1]);
}
function keys(x) {
    return x[0];
}
function values(x) {
    return x[1];
}
function* entries(x) {
    var iv = values(x)[Symbol.iterator]();
    for (var k of keys(x))
        yield [k, iv.next().value];
}
function fromEntries(x) {
    var ex = toMany(x);
    return [keys$1(ex), values$1(ex)];
}
function size(x) {
    return length(keys(x));
}
function isEmpty(x) {
    return isEmpty$1(keys(x));
}
function compare(x, y, fc = null, fm = null) {
    return compare$1(fromLists(x), fromLists(y), fc, fm);
}
function isEqual(x, y, fc = null, fm = null) {
    return compare(x, y, fc, fm) === 0;
}
function get(x, k) {
    return get$2(entries(x), k);
}
function getAll(x, ks) {
    return getAll$2(fromLists(x), ks);
}
function getPath(x, p) {
    for (var k of p)
        x = is(x) ? get(x, k) : undefined;
    return x;
}
function hasPath(x, p) {
    return getPath(x, p) !== undefined;
}
function set(x, k, v) {
    var ks = [], vs = [];
    for (var [j, u] of entries(x)) {
        ks.push(j);
        vs.push(j === k ? v : u);
    }
    return [ks, vs];
}
function swap(x, k, l) {
    var ks = map$1(keys(x), j => j === k ? l : (j === l ? k : j));
    return [ks, values(x)];
}
function remove(x, k) {
    var ks = [], vs = [];
    for (var [j, u] of entries(x)) {
        if (j === k)
            continue;
        ks.push(j);
        vs.push(u);
    }
    return [ks, vs];
}
function head(x, ed = []) {
    return head$1(entries(x), ed);
}
function tail(x) {
    return drop(x, 1);
}
function take(x, n = 1) {
    var ks = take$1(keys(x), n);
    var vs = take$1(values(x), n);
    return [ks, vs];
}
function drop(x, n = 1) {
    var ks = drop$1(keys(x), n);
    var vs = drop$1(values(x), n);
    return [ks, vs];
}
function count(x, ft) {
    return count$1(entries(x), ft);
}
function countAs(x, fm = null) {
    return countAs$1(entries(x), fm);
}
function min(x, fc = null, fm = null) {
    return rangeEntries(x, fc, fm)[0][1];
}
function minEntry(x, fc = null, fm = null) {
    return rangeEntries(x, fc, fm)[0];
}
function max(x, fc = null, fm = null) {
    return rangeEntries(x, fc, fm)[1][1];
}
function maxEntry(x, fc = null, fm = null) {
    return rangeEntries(x, fc, fm)[1];
}
function range(x, fc = null, fm = null) {
    var [a, b] = rangeEntries(x, fc, fm);
    return [a[1], b[1]];
}
function rangeEntries(x, fc = null, fm = null) {
    return rangeEntries$1(entries(x), fc, fm);
}
function* subsets(x, n = -1) {
    for (var a of subsets$1(fromLists(x), n))
        yield [a.keys(), a.values()];
}
function randomKey(x, fr = Math.random) {
    return randomValue$1([...keys(x)], fr);
}
function randomValue(x, fr = Math.random) {
    return randomValue$1([...values(x)], fr);
}
function randomEntry(x, fr = Math.random) {
    return randomValue$1([...entries(x)], fr);
}
function randomSubset(x, n = -1, fr = Math.random) {
    var a = randomSubset$1(fromLists(x), n, fr);
    return [a.keys(), a.values()];
}
function has(x, k) {
    return hasValue$1(keys(x), k);
}
function hasValue(x, v, fc = null, fm = null) {
    return searchValue(x, v, fc, fm) !== undefined;
}
function hasEntry(x, e, fc = null, fm = null) {
    var fc = fc || COMPARE$3;
    var fm = fm || IDENTITY$3;
    var [k, v] = e, u = get(x, k);
    var u1 = fm(u, k, x);
    var v1 = fm(v, k, x);
    return fc(u1, v1) === 0;
}
function hasSubset(x, y, fc = null, fm = null) {
    return hasSubset$1(fromLists(x), fromLists(y), fc, fm);
}
function find(x, ft) {
    return find$1(entries(x), ft);
}
function findAll(x, ft) {
    return findAll$1(entries(x), ft);
}
function search(x, ft) {
    return search$1(entries(x), ft);
}
function searchAll(x, ft) {
    return searchAll$1(entries(x), ft);
}
function searchValue(x, v, fc = null, fm = null) {
    return searchValue$1(entries(x), v, fc, fm);
}
function searchValueAll(x, v, fc = null, fm = null) {
    return searchValueAll$1(entries(x), v, fc, fm);
}
function forEach(x, fc) {
    forEach$1(entries(x), fc);
}
function some(x, ft = null) {
    return some$2(entries(x), ft);
}
function every(x, ft) {
    return every$1(entries(x), ft);
}
function map(x, fm) {
    var ks = [], vs = [];
    for (var [k, v] of entries(x)) {
        ks.push(k);
        vs.push(fm(v, k, x));
    }
    return [ks, vs];
}
function reduce(x, fr, acc) {
    var A = arguments.length, es = entries(x);
    return A > 2 ? reduce$1(es, fr, acc) : reduce$1(es, fr);
}
function filter(x, ft) {
    var ks = [], vs = [];
    for (var [k, v] of entries(x))
        if (ft(v, k, x)) {
            ks.push(k);
            vs.push(v);
        }
    return [ks, vs];
}
function filterAt(x, ks) {
    var js = [], us = [];
    for (var [k, v] of entries(x))
        if (ks.includes(k)) {
            js.push(k);
            us.push(v);
        }
    return [js, us];
}
function reject(x, ft) {
    var ks = [], vs = [];
    for (var [k, v] of entries(x))
        if (!ft(v, k, x)) {
            ks.push(k);
            vs.push(v);
        }
    return [ks, vs];
}
function rejectAt(x, ks) {
    var js = [], us = [];
    for (var [k, v] of entries(x))
        if (!ks.includes(k)) {
            js.push(k);
            us.push(v);
        }
    return [js, us];
}
function flat(x, n = -1, fm = null, ft = null) {
    var fm = fm || IDENTITY$3;
    var ft = ft || is;
    var a = flatTo$(new Map(), x, n, fm, ft);
    return [a.keys(), a.values()];
}
function flatTo$(a, x, n, fm, ft) {
    for (var [k, v] of entries(x)) {
        var v1 = fm(v, k, x);
        if (n !== 0 && ft(v1, k, x))
            flatTo$(a, v1, n - 1, fm, ft);
        else
            a.set(k, v1);
    }
    return a;
}
function flatMap(x, fm = null, ft = null) {
    var fm = fm || IDENTITY$3;
    var ft = ft || is;
    var a = new Map();
    for (var [k, v] of entries(x)) {
        var w = fm(v, k, x);
        if (ft(w, k, x))
            concat$(a, entries(w));
        else
            a.set(k, w);
    }
    return [a.keys(), a.values()];
}
function zip(xs, fm = null, ft = null, vd) {
    var a = zip$1(xs.map(x => new Map(entries(x))), fm, ft, vd);
    return [a.keys(), a.values()];
}
function partition(x, ft) {
    var tk = [], tv = [], fk = [], fv = [];
    for (var [k, v] of entries(x)) {
        if (ft(v, k, x)) {
            tk.push(k);
            tv.push(v);
        }
        else {
            fk.push(k);
            fv.push(v);
        }
    }
    return [[tk, tv], [fk, fv]];
}
function partitionAs(x, fm = null) {
    var fm = fm || IDENTITY$3;
    var a = new Map();
    for (var [k, v] of entries(x)) {
        var v1 = fm(v, k, x);
        if (!a.has(v1))
            a.set(v1, [[], []]);
        var [ak, av] = a.get(v1);
        ak.push(k);
        av.push(v);
    }
    return a;
}
function chunk(x, n = 1, s = n) {
    var kss = chunk$1([...keys(x)], n, s);
    var vss = chunk$1([...values(x)], n, s);
    return zip$2([kss, vss]);
}
function concat(...xs) {
    var ks = concat$2(...xs.map(keys));
    var vs = concat$2(...xs.map(values));
    var a = fromLists([ks, vs]);
    return [a.keys(), a.values()];
}
function join(x, sep = ',', asc = '=') {
    return join$1(entries(x), sep, asc);
}
function isDisjoint(x, y) {
    return isDisjoint$1(new Set(keys(x)), keys(y));
}
function unionKeys(...xs) {
    return concat$1(...xs.map(x => new Set(keys(x))));
}
function union(x, y, fc = null) {
    var a = union$1(entries(x), entries(y), fc);
    return [a.keys(), a.values()];
}
function intersection(x, y, fc = null) {
    var a = intersection$1(new Map(entries(x)), entries(y), fc);
    return [a.keys(), a.values()];
}
function difference(x, y) {
    var a = fromLists(x);
    for (var k of keys(y))
        a.delete(k);
    return [a.keys(), a.values()];
}
function symmetricDifference(x, y) {
    var a = symmetricDifference$1(entries(x), entries(y));
    return [a.keys(), a.values()];
}

exports.chunk = chunk;
exports.compare = compare;
exports.concat = concat;
exports.count = count;
exports.countAs = countAs;
exports.difference = difference;
exports.drop = drop;
exports.entries = entries;
exports.entry = randomEntry;
exports.every = every;
exports.filter = filter;
exports.filterAt = filterAt;
exports.find = find;
exports.findAll = findAll;
exports.flat = flat;
exports.flatMap = flatMap;
exports.forEach = forEach;
exports.fromEntries = fromEntries;
exports.get = get;
exports.getAll = getAll;
exports.getPath = getPath;
exports.has = has;
exports.hasEntry = hasEntry;
exports.hasPath = hasPath;
exports.hasSubset = hasSubset;
exports.hasValue = hasValue;
exports.head = head;
exports.intersection = intersection;
exports.is = is;
exports.isDisjoint = isDisjoint;
exports.isEmpty = isEmpty;
exports.isEqual = isEqual;
exports.join = join;
exports.key = randomKey;
exports.keys = keys;
exports.length = size;
exports.map = map;
exports.max = max;
exports.maxEntry = maxEntry;
exports.min = min;
exports.minEntry = minEntry;
exports.partition = partition;
exports.partitionAs = partitionAs;
exports.randomEntry = randomEntry;
exports.randomKey = randomKey;
exports.randomSubset = randomSubset;
exports.randomValue = randomValue;
exports.range = range;
exports.rangeEntries = rangeEntries;
exports.reduce = reduce;
exports.reject = reject;
exports.rejectAt = rejectAt;
exports.remove = remove;
exports.search = search;
exports.searchAll = searchAll;
exports.searchValue = searchValue;
exports.searchValueAll = searchValueAll;
exports.set = set;
exports.size = size;
exports.some = some;
exports.subset = randomSubset;
exports.subsets = subsets;
exports.swap = swap;
exports.symmetricDifference = symmetricDifference;
exports.tail = tail;
exports.take = take;
exports.union = union;
exports.unionKeys = unionKeys;
exports.value = randomValue;
exports.values = values;
exports.zip = zip;