extra-lists/index.mjs

A collection of functions for operating upon Lists.

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()];
}

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