extra-entries/index.mjs

A collection of functions for operating upon Entries.

function IDENTITY$1(v) {
    return v;
}
function COMPARE$1(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 isEmpty(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(x, vd) {
    for (var v of x)
        return v;
    return vd;
}
function* tail(x) {
    var i = -1;
    for (var v of x)
        if (++i > 0)
            yield v;
}
function take(x, n = 1) {
    return slice(x, 0, n);
}
function drop(x, n = 1) {
    return slice(x, n);
}

function randomValue$1(x, fr = Math.random) {
    var i = Math.floor(fr() * x.length);
    return x[i];
}

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) {
    return [...isubsequences(x, n)];
}
function* isubsequences(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* isubsequences(y, n);
    for (var s of isubsequences(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 is(v) {
    return v instanceof Map;
}
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 swap$(x, k, l) {
    var t = x.get(k);
    x.set(k, x.get(l));
    x.set(l, t);
    return x;
}
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 flat$1(x, n = -1, fm = null, ft = null) {
    var fm = fm || IDENTITY;
    var ft = ft || is;
    return flatTo$(new Map(), x, n, fm, ft);
}
function flatTo$(a, x, n, fm, ft) {
    for (var [k, v] of x) {
        var w = fm(v, k, x);
        if (n !== 0 && ft(w, k, x))
            flatTo$(a, w, n - 1, fm, ft);
        else
            a.set(k, w);
    }
    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 chunk$1(x, n = 1, s = n) {
    var ks = [...x.keys()], a = [];
    for (var i = 0, I = ks.length; i < I; i += s)
        a.push(filterAt$1(x, ks.slice(i, i + n)));
    return a;
}
function concat$1(...xs) {
    return concat$(new Map(), ...xs);
}
function concat$(x, ...ys) {
    for (var y of ys) {
        for (var [k, v] of y)
            x.set(k, v);
    }
    return x;
}
function isDisjoint$1(x, y) {
    for (var [k] of y)
        if (x.has(k))
            return false;
    return true;
}
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 difference$1(x, y) {
    return difference$(new Map(x), y);
}
function difference$(x, y) {
    for (var [k] of y)
        x.delete(k);
    return x;
}
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* keys(x) {
    for (var [k] of x)
        yield k;
}
function* values(x) {
    for (var [, v] of x)
        yield v;
}
function* fromLists(x) {
    var [ks, vs] = x;
    var iv = vs[Symbol.iterator]();
    for (var k of ks)
        yield [k, iv.next().value];
}
function compare(x, y, fc = null, fm = null) {
    return compare$1(new Map(x), new Map(y), fc, fm);
}
function isEqual(x, y, fc = null, fm = null) {
    return compare(x, y, fc, fm) === 0;
}
function get(x, k) {
    for (var [j, u] of x)
        if (j === k)
            return u;
}
function getAll(x, ks) {
    var m = new Map();
    for (var [k, v] of x)
        if (ks.includes(k))
            m.set(k, v);
    var a = [];
    for (var k of ks)
        a.push(m.get(k));
    return a;
}
function getPath(x, p) {
    for (var k of p)
        x = is$1(x) ? get(x, k) : undefined;
    return x;
}
function hasPath(x, p) {
    return getPath(x, p) !== undefined;
}
function* set(x, k, v) {
    for (var [j, u] of x)
        yield j === k ? [j, v] : [j, u];
}
function swap(x, k, l) {
    return swap$(new Map(x), k, l);
}
function* remove(x, k) {
    for (var [j, u] of x)
        if (j !== k)
            yield [j, u];
}
function count(x, ft) {
    var a = 0;
    for (var [k, v] of x)
        if (ft(v, k, x))
            ++a;
    return a;
}
function countAs(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 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) {
    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* subsets(x, n = -1) {
    yield* subsets$1(new Map(x), n);
}
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([...x], fr);
}
function randomSubset(x, n = -1, fr = Math.random) {
    return randomSubset$1(new Map(x), n, fr);
}
function has(x, k) {
    for (var [j] of x)
        if (j === k)
            return true;
    return false;
}
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$1;
    var fm = fm || IDENTITY$1;
    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(new Map(x), new Map(y), fc, fm);
}
function find(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            return v;
}
function* findAll(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            yield v;
}
function search(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            return k;
}
function* searchAll(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            yield k;
}
function searchValue(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(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(x, fp) {
    for (var [k, v] of x)
        fp(v, k, x);
}
function some(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            return true;
    return false;
}
function every(x, ft) {
    for (var [k, v] of x)
        if (!ft(v, k, x))
            return false;
    return true;
}
function* map(x, fm) {
    for (var [k, v] of x)
        yield [k, fm(v, k, x)];
}
function reduce(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* filter(x, ft) {
    for (var [k, v] of x)
        if (ft(v, k, x))
            yield [k, v];
}
function* filterAt(x, ks) {
    for (var [k, v] of x)
        if (ks.includes(k))
            yield [k, v];
}
function* reject(x, ft) {
    for (var [k, v] of x)
        if (!ft(v, k, x))
            yield [k, v];
}
function* rejectAt(x, ks) {
    for (var [k, v] of x)
        if (!ks.includes(k))
            yield [k, v];
}
function flat(x, n = -1, fm = null, ft = null) {
    return flat$1(x, n, fm, ft || is$1);
}
function flatMap(x, fm = null, ft = null) {
    var fm = fm || IDENTITY$1;
    var ft = ft || is$1;
    var a = new Map();
    for (var [k, v] of x) {
        var v1 = fm(v, k, x);
        if (ft(v1, k, x))
            concat$(a, v1);
        else
            a.set(k, v1);
    }
    return a;
}
function zip(xs, fm = null, ft = null, vd) {
    return zip$1(xs.map(x => new Map(x)), fm, ft, vd);
}
function partition(x, ft) {
    var t = [], f = [];
    for (var [k, v] of x) {
        if (ft(v, k, x))
            t.push([k, v]);
        else
            f.push([k, v]);
    }
    return [t, f];
}
function partitionAs(x, fm) {
    var fm = fm || IDENTITY$1;
    var a = new Map();
    for (var [k, v] of x) {
        var v1 = fm(v, k, x);
        if (!a.has(v1))
            a.set(v1, []);
        a.get(v1).push([k, v]);
    }
    return a;
}
function chunk(x, n = 1, s = n) {
    return chunk$1(new Map(x), n, s);
}
function concat(...xs) {
    return concat$1(...xs);
}
function join(x, sep = ",", asc = "=") {
    var a = "";
    for (var [k, v] of x)
        a += k + asc + v + sep;
    return a.slice(0, -sep.length);
}
function isDisjoint(x, y) {
    return isDisjoint$1(new Map(x), y);
}
function unionKeys(...xs) {
    return unionKeys$1(...xs);
}
function union(x, y, fc = null) {
    return union$1(x, y, fc);
}
function intersection(x, y, fc = null) {
    return intersection$1(new Map(x), y, fc);
}
function difference(x, y) {
    return difference$1(x, y);
}
function symmetricDifference(x, y) {
    return symmetricDifference$1(x, y);
}

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